| f | submodule Cisco-IOS-XR-ipv4-bgp-oper-sub1 { | f | submodule Cisco-IOS-XR-ipv4-bgp-oper-sub1 { |
| belongs-to Cisco-IOS-XR-ipv4-bgp-oper { | | belongs-to Cisco-IOS-XR-ipv4-bgp-oper { |
| prefix Cisco-IOS-XR-ipv4-bgp-oper; | | prefix Cisco-IOS-XR-ipv4-bgp-oper; |
| } | | } |
| | | |
| import ietf-inet-types { | | import ietf-inet-types { |
| prefix inet; | | prefix inet; |
| } | | } |
| import ietf-yang-types { | | import ietf-yang-types { |
| prefix yang; | | prefix yang; |
| } | | } |
| import Cisco-IOS-XR-types { | | import Cisco-IOS-XR-types { |
| prefix xr; | | prefix xr; |
| n | } | n | |
| import cisco-semver { | | |
| prefix semver; | | |
| } | | } |
| | | |
| organization | | organization |
| "Cisco Systems, Inc."; | | "Cisco Systems, Inc."; |
| contact | | contact |
| "Cisco Systems, Inc. | | "Cisco Systems, Inc. |
| Customer Service | | Customer Service |
| | | |
| Postal: 170 West Tasman Drive | | Postal: 170 West Tasman Drive |
| San Jose, CA 95134 | | San Jose, CA 95134 |
| | | |
| Tel: +1 800 553-NETS | | Tel: +1 800 553-NETS |
| | | |
| E-mail: cs-yang@cisco.com"; | | E-mail: cs-yang@cisco.com"; |
| description | | description |
| "This submodule contains a collection of YANG definitions | | "This submodule contains a collection of YANG definitions |
| for Cisco IOS-XR ipv4-bgp package operational data. | | for Cisco IOS-XR ipv4-bgp package operational data. |
| | | |
| n | Copyright (c) 2013-2024 by Cisco Systems, Inc. | n | Copyright (c) 2013-2018 by Cisco Systems, Inc. |
| All rights reserved."; | | All rights reserved."; |
| | | |
| n | revision 2024-04-29 { | n | |
| description | | |
| "Modified BGP Prefix Stats bag | | |
| 2024-04-29 | | |
| Added LastOORRecovery for perf process af vrf | | |
| 2024-04-29 | | |
| Added BGP ECMP and prefix tuple bag | | |
| 2024-02-15 | | |
| Added new fields for process info af vrf | | |
| 2024-02-15 | | |
| Added new fields for perf process af vrf | | |
| 2024-02-15 | | |
| Added new fields for bgp nbr af | | |
| 2024-01-31 | | |
| Obsoleted container bmp-paths | | |
| 2023-12-20 | | |
| Added new fields for process info af vrf | | |
| 2023-12-20 | | |
| Added new fields for process info af gbl | | |
| 2023-12-20 | | |
| Added new fields for net bag | | |
| 2023-12-20 | | |
| Added new fields for bgp nbr af | | |
| 2023-12-08 | | |
| Added new field for srv6 mode and srv6 locator id in net bag | | |
| 2023-12-05 | | |
| Added new field to dry run policy stats bag for walk resume/completion | | |
| 2023-12-04 | | |
| Added new bag for memory high water mark table | | |
| 2023-11-10 | | |
| Added readQs and writeQs size to optimise show bgp convergence command | | |
| 2023-10-25 | | |
| Changed variables for show bgp version and show bmp table version commands from string to uint64 | | |
| 2023-10-22 | | |
| Added new segment-list and odn type for sr policy nexthop | | |
| 2023-10-20 | | |
| Added Policy based nexthop-self information in process details | | |
| 2023-10-02 | | |
| Added new field to dry run policy stats bag | | |
| 2023-09-27 | | |
| Changed rib-convergence-version from uint64 to uint32 | | |
| 2023-09-13 | | |
| Updated BGP neighbor, session, NSR and nexthop models for monitoring enhancements | | |
| 2023-08-23 | | |
| New command show bgp l2vpn evpn gateway-track | | |
| 2023-08-09 | | |
| Modified range of memory-info-entry index | | |
| 2023-07-28 | | |
| Dry run policy stats change added. | | |
| 2023-07-05 | | |
| Added new field to neighbor bag related to sync elem flag | | |
| 2023-06-19 | | |
| Update show bgp vpnv4 unicast rd prefix to include allocated and received secondary label | | |
| 2023-04-28 | | |
| Added show bgp memory history command | | |
| 2023-04-19 | | |
| Added new field to net bag | | |
| 2023-02-03 | | |
| Updated show bgp nexthop-set output to include retain-counter and show bgp label to include RPC information | | |
| 2023-01-18 | | |
| Updated BMP path information to include link-local nexthop and netxhop route-distinguisher information | | |
| 2023-01-10 | | |
| Added support for Pre-policy mode convergence and updated BGP-BMP-CONVERGENCE-BAG grouping | | |
| 2022-12-22 | | |
| Changed neighbor bag for LPTS secure binding | | |
| 2022-12-11 | | |
| Updated Neighbor show command to include evpn-link-bandwidth values. | | |
| 2022-11-11 | | |
| Modified type of Last Received Message in per-neighbor information | | |
| 2022-11-03 | | |
| Added oc-rib attribute index in BGP path information | | |
| 2022-10-14 | | |
| Added Last Received Message for per neighbor | | |
| 2022-10-06 | | |
| Added server states in per BMP server convergence data | | |
| 2022-10-04 | | |
| Added delay and other timers for BMP server | | |
| 2022-09-23 | | |
| Added BMP route-monitoring suport for L3VPN inbound post-policy and Local RIB, Deprecated container policy under route-monitoring | | |
| 2022-09-21 | | |
| Added prefix received counter to count the routes received before ingress policy run | | |
| 2022-06-02 | | |
| Added update wait install delay leaf. | | |
| 2022-05-17 | | |
| Added srte bgp prefix label ignore flag to nexthop | | |
| 2022-02-18 | | |
| Added interface-name key to next-hop-af leaf. | | |
| 2022-02-07 | | |
| Added address family string under af-array | | |
| 2021-11-29 | | |
| Added next hop encapsulation type for MPLS over UDP tunnel | | |
| 2021-11-15 | | |
| Added interafi leak information in update out | | |
| 2021-11-12 | | |
| Updated convergence operational information | | |
| 2021-11-09 | | |
| Added oper for Nexthop sync slot"; | | |
| semver:module-version "6.0.0"; | | |
| } | | |
| revision 2021-10-16 { | | |
| description | | |
| "Added Oper for mamximum-paths deterministic | | |
| 2021-06-27 | | |
| Added PathLocalSidTable and PathReceivedSidTable"; | | |
| semver:module-version "5.0.0"; | | |
| } | | |
| revision 2021-05-10 { | | |
| description | | |
| "Added platform capability mix srte CLI | | |
| 2021-03-15 | | |
| Added Export Allow Config for backup | | |
| 2021-03-05 | | |
| Deprecated Hidden commands | | |
| 2021-03-05 | | |
| Added SR Policy Path Prefernce in Bestpath Compare | | |
| 2020-10-04 | | |
| Added Soft NextHop Validation and Metric | | |
| 2020-09-30 | | |
| Added LATEST bestpath comparison reason | | |
| 2020-09-18 | | |
| Added SRv6 TE BSID information | | |
| 2020-07-15 | | |
| Changed VRFDBVRFTable pathformat"; | | |
| semver:module-version "4.0.0"; | | |
| } | | |
| revision 2020-06-23 { | | |
| description | | |
| "changed the afi from integer to string in BPM entities | | |
| 2020-03-30 | | |
| Extended flags to 16 bits and changed leaf names as per convention"; | | |
| semver:module-version "3.0.0"; | | |
| } | | |
| revision 2020-01-11 { | | |
| description | | |
| "Fixing invalid range for prefix length. | | |
| 2019-08-31 | | |
| Fixing revision error in module."; | | |
| semver:module-version "2.0.0"; | | |
| } | | |
| revision 2019-04-05 { | | |
| description | | |
| "Fixing backward compatibility error in module"; | | |
| semver:module-version "1.0.0"; | | |
| } | | |
| revision 2019-04-05 { | | |
| description | | |
| "Added schema for opercoverage missing paths"; | | |
| } | | |
| revision 2019-04-05 { | | |
| description | | |
| "Establish semantic version baseline."; | | |
| } | | |
| revision 2017-09-07 { | | revision 2017-09-07 { |
| description | | description |
| "Fixed type translation error."; | | "Fixed type translation error."; |
| } | | } |
| revision 2017-06-26 { | | revision 2017-06-26 { |
| description | | description |
| "Change identifiers to be more readable."; | | "Change identifiers to be more readable."; |
| } | | } |
| revision 2017-05-01 { | | revision 2017-05-01 { |
| description | | description |
| "Fixing backward compatibility error in module."; | | "Fixing backward compatibility error in module."; |
| } | | } |
| revision 2015-08-27 { | | revision 2015-08-27 { |
| description | | description |
| "IOS XR 5.3.2 revision."; | | "IOS XR 5.3.2 revision."; |
| } | | } |
| | | |
| typedef Bgp-label-rpf-install { | | typedef Bgp-label-rpf-install { |
| type enumeration { | | type enumeration { |
| enum "bgp-label-rpf-install-rib" { | | enum "bgp-label-rpf-install-rib" { |
| value 0; | | value 0; |
| description | | description |
| "Install via RIB"; | | "Install via RIB"; |
| } | | } |
| enum "bgp-label-rpf-install-lsd" { | | enum "bgp-label-rpf-install-lsd" { |
| value 1; | | value 1; |
| description | | description |
| "Install via LSD"; | | "Install via LSD"; |
| } | | } |
| } | | } |
| description | | description |
| "BGP Label RPF Install Path"; | | "BGP Label RPF Install Path"; |
| } | | } |
| | | |
| typedef Bgp-rpki-perror { | | typedef Bgp-rpki-perror { |
| type enumeration { | | type enumeration { |
| enum "none" { | | enum "none" { |
| description | | description |
| "No protocol error"; | | "No protocol error"; |
| } | | } |
| enum "message-version" { | | enum "message-version" { |
| description | | description |
| "Message version error"; | | "Message version error"; |
| } | | } |
| enum "message-type" { | | enum "message-type" { |
| description | | description |
| "Message type error"; | | "Message type error"; |
| } | | } |
| enum "message-length" { | | enum "message-length" { |
| description | | description |
| "Message length error"; | | "Message length error"; |
| } | | } |
| enum "nonce-mismatch" { | | enum "nonce-mismatch" { |
| description | | description |
| "Server nonce mismatch"; | | "Server nonce mismatch"; |
| } | | } |
| enum "bad-prefix" { | | enum "bad-prefix" { |
| description | | description |
| "Bad ROA"; | | "Bad ROA"; |
| } | | } |
| enum "fsm" { | | enum "fsm" { |
| description | | description |
| "FSM error"; | | "FSM error"; |
| } | | } |
| enum "no-response" { | | enum "no-response" { |
| description | | description |
| "No response from server"; | | "No response from server"; |
| } | | } |
| enum "error-report" { | | enum "error-report" { |
| description | | description |
| "Server sent error-report"; | | "Server sent error-report"; |
| } | | } |
| } | | } |
| description | | description |
| "Bgp rpki perror"; | | "Bgp rpki perror"; |
| } | | } |
| | | |
| typedef Bgp-rpki-pstate { | | typedef Bgp-rpki-pstate { |
| type enumeration { | | type enumeration { |
| enum "not-started" { | | enum "not-started" { |
| description | | description |
| "Server protocol has not started"; | | "Server protocol has not started"; |
| } | | } |
| enum "reset" { | | enum "reset" { |
| description | | description |
| "Server protocol reset"; | | "Server protocol reset"; |
| } | | } |
| enum "refresh" { | | enum "refresh" { |
| description | | description |
| "Server protocol resumed"; | | "Server protocol resumed"; |
| } | | } |
| enum "reset-query-sent" { | | enum "reset-query-sent" { |
| description | | description |
| "Reset query sent to server"; | | "Reset query sent to server"; |
| } | | } |
| enum "serial-query-sent" { | | enum "serial-query-sent" { |
| description | | description |
| "Serial query sent to server"; | | "Serial query sent to server"; |
| } | | } |
| enum "data-start" { | | enum "data-start" { |
| description | | description |
| "Server started sending data"; | | "Server started sending data"; |
| } | | } |
| enum "data-end" { | | enum "data-end" { |
| description | | description |
| "Server ended sending data"; | | "Server ended sending data"; |
| } | | } |
| } | | } |
| description | | description |
| "Bgp rpki pstate"; | | "Bgp rpki pstate"; |
| } | | } |
| | | |
| typedef Bgp-rpki-creason { | | typedef Bgp-rpki-creason { |
| type enumeration { | | type enumeration { |
| enum "no-close-reason" { | | enum "no-close-reason" { |
| value 0; | | value 0; |
| description | | description |
| "No close reason"; | | "No close reason"; |
| } | | } |
| enum "read-error" { | | enum "read-error" { |
| value 1; | | value 1; |
| description | | description |
| "Socket Read error"; | | "Socket Read error"; |
| } | | } |
| enum "write-error" { | | enum "write-error" { |
| value 2; | | value 2; |
| description | | description |
| "Socket Write error"; | | "Socket Write error"; |
| } | | } |
| enum "proto-error" { | | enum "proto-error" { |
| value 3; | | value 3; |
| description | | description |
| "Protocol error"; | | "Protocol error"; |
| } | | } |
| enum "config-shutdown" { | | enum "config-shutdown" { |
| value 4; | | value 4; |
| description | | description |
| "Shutdown by configuration"; | | "Shutdown by configuration"; |
| } | | } |
| enum "config-removed" { | | enum "config-removed" { |
| value 5; | | value 5; |
| description | | description |
| "Configuration removed"; | | "Configuration removed"; |
| } | | } |
| enum "config-changed" { | | enum "config-changed" { |
| value 6; | | value 6; |
| description | | description |
| "Configuration changed"; | | "Configuration changed"; |
| } | | } |
| enum "nsr-disabled" { | | enum "nsr-disabled" { |
| value 7; | | value 7; |
| description | | description |
| "NSR disabled"; | | "NSR disabled"; |
| } | | } |
| enum "user-clear" { | | enum "user-clear" { |
| value 8; | | value 8; |
| description | | description |
| "Explicity user clear"; | | "Explicity user clear"; |
| } | | } |
| enum "ssh-died" { | | enum "ssh-died" { |
| value 9; | | value 9; |
| description | | description |
| "SSH process died"; | | "SSH process died"; |
| } | | } |
| enum "tcp-died" { | | enum "tcp-died" { |
| value 10; | | value 10; |
| description | | description |
| "TCP process died"; | | "TCP process died"; |
| } | | } |
| } | | } |
| description | | description |
| "Bgp rpki creason"; | | "Bgp rpki creason"; |
| } | | } |
| | | |
| typedef Bgp-rpki-state { | | typedef Bgp-rpki-state { |
| type enumeration { | | type enumeration { |
| enum "idle" { | | enum "idle" { |
| value 0; | | value 0; |
| description | | description |
| "Server is idle"; | | "Server is idle"; |
| } | | } |
| enum "attempt-connect" { | | enum "attempt-connect" { |
| value 1; | | value 1; |
| description | | description |
| "Connect attempt made to server"; | | "Connect attempt made to server"; |
| } | | } |
| enum "connected" { | | enum "connected" { |
| value 2; | | value 2; |
| description | | description |
| "Server is connected"; | | "Server is connected"; |
| } | | } |
| } | | } |
| description | | description |
| "Bgp rpki state"; | | "Bgp rpki state"; |
| } | | } |
| | | |
| typedef Bgp-ism-conn-state { | | typedef Bgp-ism-conn-state { |
| type enumeration { | | type enumeration { |
| enum "none" { | | enum "none" { |
| description | | description |
| "None - ST 0"; | | "None - ST 0"; |
| } | | } |
| enum "connect-done" { | | enum "connect-done" { |
| description | | description |
| "ISSUMgr connection done - ST 1"; | | "ISSUMgr connection done - ST 1"; |
| } | | } |
| } | | } |
| description | | description |
| "Bgp ism conn state"; | | "Bgp ism conn state"; |
| } | | } |
| | | |
| typedef Bgp-ds-conn-state { | | typedef Bgp-ds-conn-state { |
| type enumeration { | | type enumeration { |
| enum "none" { | | enum "none" { |
| description | | description |
| "DS connection not initiated - ST 0"; | | "DS connection not initiated - ST 0"; |
| } | | } |
| enum "connect-init" { | | enum "connect-init" { |
| description | | description |
| "DS connection initiated - ST 1"; | | "DS connection initiated - ST 1"; |
| } | | } |
| enum "connect-fail" { | | enum "connect-fail" { |
| description | | description |
| "DS connection failed - ST 2"; | | "DS connection failed - ST 2"; |
| } | | } |
| enum "connect-estb" { | | enum "connect-estb" { |
| description | | description |
| "DS connection established - ST 3"; | | "DS connection established - ST 3"; |
| } | | } |
| enum "disconnect-init" { | | enum "disconnect-init" { |
| description | | description |
| "DS disconnect initiated - ST 4"; | | "DS disconnect initiated - ST 4"; |
| } | | } |
| enum "disconnect-fail" { | | enum "disconnect-fail" { |
| description | | description |
| "DS disconnect failed - ST 5"; | | "DS disconnect failed - ST 5"; |
| } | | } |
| enum "disconnect-done" { | | enum "disconnect-done" { |
| description | | description |
| "DS disconnect done - ST 6"; | | "DS disconnect done - ST 6"; |
| } | | } |
| } | | } |
| description | | description |
| "Bgp ds conn state"; | | "Bgp ds conn state"; |
| } | | } |
| | | |
| typedef Bgp-scoped-sync-state { | | typedef Bgp-scoped-sync-state { |
| type enumeration { | | type enumeration { |
| enum "bgp-scope-sync-state-none" { | | enum "bgp-scope-sync-state-none" { |
| description | | description |
| "State none"; | | "State none"; |
| } | | } |
| enum "bgp-scope-sync-state-not-nsr-ready" { | | enum "bgp-scope-sync-state-not-nsr-ready" { |
| description | | description |
| "Oper Down when NSR not ready"; | | "Oper Down when NSR not ready"; |
| } | | } |
| enum "bgp-scope-sync-state-timer-start" { | | enum "bgp-scope-sync-state-timer-start" { |
| description | | description |
| "Timer started for active batch"; | | "Timer started for active batch"; |
| } | | } |
| enum "bgp-scope-sync-state-add-list" { | | enum "bgp-scope-sync-state-add-list" { |
| description | | description |
| "Start adding neighbors to pending batch"; | | "Start adding neighbors to pending batch"; |
| } | | } |
| enum "bgp-scope-sync-state-batch-acitve" { | | enum "bgp-scope-sync-state-batch-acitve" { |
| description | | description |
| "Active batch"; | | "Active batch"; |
| } | | } |
| } | | } |
| description | | description |
| "Bgp scoped sync state"; | | "Bgp scoped sync state"; |
| } | | } |
| | | |
| typedef Bgp-bmp-upd-mode { | | typedef Bgp-bmp-upd-mode { |
| type enumeration { | | type enumeration { |
| enum "bgp-bmp-upd-n-either" { | | enum "bgp-bmp-upd-n-either" { |
| value 0; | | value 0; |
| description | | description |
| "Neither of the modes are enabled"; | | "Neither of the modes are enabled"; |
| } | | } |
| enum "bgp-bmp-upd-route-mon" { | | enum "bgp-bmp-upd-route-mon" { |
| value 1; | | value 1; |
| description | | description |
| "Route Monotoring mode enabled"; | | "Route Monotoring mode enabled"; |
| } | | } |
| enum "bgp-bmp-upd-route-mirr" { | | enum "bgp-bmp-upd-route-mirr" { |
| value 2; | | value 2; |
| description | | description |
| "Route Mirroring mode is enabled"; | | "Route Mirroring mode is enabled"; |
| } | | } |
| } | | } |
| description | | description |
| "Bgp bmp upd mode"; | | "Bgp bmp upd mode"; |
| } | | } |
| | | |
| typedef Bgp-bmp-state { | | typedef Bgp-bmp-state { |
| type enumeration { | | type enumeration { |
| enum "none" { | | enum "none" { |
| value 0; | | value 0; |
| description | | description |
| "BMP NOT Connected"; | | "BMP NOT Connected"; |
| } | | } |
| enum "connecting" { | | enum "connecting" { |
| value 1; | | value 1; |
| description | | description |
| "BMP Under Connection"; | | "BMP Under Connection"; |
| } | | } |
| enum "established" { | | enum "established" { |
| value 2; | | value 2; |
| description | | description |
| "BMP Connection Established"; | | "BMP Connection Established"; |
| } | | } |
| enum "closing" { | | enum "closing" { |
| value 3; | | value 3; |
| description | | description |
| "BMP Connection Closing"; | | "BMP Connection Closing"; |
| } | | } |
| } | | } |
| description | | description |
| "BMP Connection State"; | | "BMP Connection State"; |
| } | | } |
| | | |
| typedef Bgp-bag-upd-filter-action { | | typedef Bgp-bag-upd-filter-action { |
| type enumeration { | | type enumeration { |
| enum "none" { | | enum "none" { |
| value 0; | | value 0; |
| description | | description |
| "No Action"; | | "No Action"; |
| } | | } |
| enum "withdraw" { | | enum "withdraw" { |
| value 1; | | value 1; |
| description | | description |
| "Withdraw NLRI"; | | "Withdraw NLRI"; |
| } | | } |
| enum "attribute-discard" { | | enum "attribute-discard" { |
| value 2; | | value 2; |
| description | | description |
| "Discard Attribute"; | | "Discard Attribute"; |
| } | | } |
| } | | } |
| description | | description |
| "Bgp bag upd filter action"; | | "Bgp bag upd filter action"; |
| } | | } |
| | | |
| typedef Bgp-bag-upd-err-action { | | typedef Bgp-bag-upd-err-action { |
| type enumeration { | | type enumeration { |
| enum "bgp-bag-upd-err-action-none" { | | enum "bgp-bag-upd-err-action-none" { |
| value 0; | | value 0; |
| description | | description |
| "No Action"; | | "No Action"; |
| } | | } |
| enum "bgp-bag-upd-err-action-discard-msg" { | | enum "bgp-bag-upd-err-action-discard-msg" { |
| value 1; | | value 1; |
| description | | description |
| "Discard Message"; | | "Discard Message"; |
| } | | } |
| enum "bgp-bag-upd-err-action-reset" { | | enum "bgp-bag-upd-err-action-reset" { |
| value 2; | | value 2; |
| description | | description |
| "Session Reset"; | | "Session Reset"; |
| } | | } |
| enum "bgp-bag-upd-err-action-wdr-or-reset" { | | enum "bgp-bag-upd-err-action-wdr-or-reset" { |
| value 3; | | value 3; |
| description | | description |
| "Withdraw NLRI or Reset"; | | "Withdraw NLRI or Reset"; |
| } | | } |
| enum "bgp-bag-upd-err-action-wdr" { | | enum "bgp-bag-upd-err-action-wdr" { |
| value 4; | | value 4; |
| description | | description |
| "Withdraw NLRI"; | | "Withdraw NLRI"; |
| } | | } |
| enum "bgp-bag-upd-err-action-discard-attr" { | | enum "bgp-bag-upd-err-action-discard-attr" { |
| value 5; | | value 5; |
| description | | description |
| "Discard Attribute"; | | "Discard Attribute"; |
| } | | } |
| enum "bgp-bag-upd-err-action-local-repair" { | | enum "bgp-bag-upd-err-action-local-repair" { |
| value 6; | | value 6; |
| description | | description |
| "Local Repair"; | | "Local Repair"; |
| } | | } |
| enum "bgp-bag-upd-err-action-max" { | | enum "bgp-bag-upd-err-action-max" { |
| value 7; | | value 7; |
| description | | description |
| "Maximum number of actions"; | | "Maximum number of actions"; |
| } | | } |
| } | | } |
| description | | description |
| "Bgp bag upd err action"; | | "Bgp bag upd err action"; |
| } | | } |
| | | |
| n | typedef Bgp-odn-policy { | n | typedef Bgp-sync-nbr-nsr-state { |
| type enumeration { | | type enumeration { |
| n | enum "bgp-odn-policy-type-srmpls" { | n | enum "bgp-nbr-nsr-st-none" { |
| value 0; | | |
| description | | |
| "On Demand Nexthop SR Policy type MPLS"; | | |
| } | | |
| enum "bgp-odn-policy-type-srv6" { | | |
| value 1; | | |
| description | | |
| "On Demand Nexthop SR Policy type SRV6"; | | |
| } | | |
| } | | |
| description | | description |
| "Bgp odn policy"; | | "None - ST 0"; |
| } | | |
| | | |
| typedef Bgp-updgen-nbr-refresh-state { | | |
| type enumeration { | | |
| enum "bgp-upd-refresh-nbr-none" { | | |
| value 0; | | |
| description | | |
| "Neighbor is not it Refresh Subgroup"; | | |
| } | | |
| enum "bgp-upd-refresh-nbr-refresh" { | | |
| value 1; | | |
| description | | |
| "Neighbor is processing Refresh"; | | |
| } | | |
| enum "bgp-upd-refresh-nbr-s-low" { | | |
| value 2; | | |
| description | | |
| "Neighbor is processing Slow(dynamic)"; | | |
| } | | |
| enum "bgp-upd-refresh-nbr-rtc" { | | |
| value 3; | | |
| description | | |
| "Neighbor is processing RTC"; | | |
| } | | |
| enum "bgp-upd-refresh-nbr-s-low-rtc" { | | |
| value 4; | | |
| description | | |
| "Neighbor is processing Slow and RTC"; | | |
| } | | |
| } | | } |
| | | enum "bgp-nbr-nsr-st-oper-down" { |
| description | | description |
| "Bgp updgen nbr refresh state"; | | "TCP OPER_DOWN notfn received - ST 1"; |
| } | | |
| | | |
| typedef Bgp-slow-peer-static-dynamic { | | |
| type enumeration { | | |
| enum "bgp-s-low-peer-upd-gen-other" { | | |
| value 0; | | |
| description | | |
| "Slow peer is other than static and dynamic | | |
| detected"; | | |
| } | | |
| enum "bgp-s-low-peer-upd-gen-static" { | | |
| value 1; | | |
| description | | |
| "Slow peer is static"; | | |
| } | | |
| enum "bgp-s-low-peer-upd-gen-dyn-detected" { | | |
| value 2; | | |
| description | | |
| "Slow peer is dynamic detected"; | | |
| } | | |
| } | | } |
| | | enum "bgp-nbr-nsr-st-tcp-init-sync" { |
| description | | description |
| "BGP slow peer state"; | | "TCP initial sync in progress - ST 2"; |
| } | | |
| | | |
| typedef Bgp-message { | | |
| type enumeration { | | |
| enum "none" { | | |
| description | | |
| "None"; | | |
| } | | |
| enum "open" { | | |
| description | | |
| "Open"; | | |
| } | | |
| enum "update" { | | |
| description | | |
| "Update"; | | |
| } | | |
| enum "notification" { | | |
| description | | |
| "Notification"; | | |
| } | | |
| enum "keepalive" { | | |
| description | | |
| "KeepAlive"; | | |
| } | | |
| enum "refresh-req" { | | |
| description | | |
| "Route-Refresh Request"; | | |
| } | | |
| } | | } |
| | | enum "bgp-nbr-nsr-st-tcp-phase-two" { |
| description | | description |
| "Bgp message"; | | "TCP initial sync phase two in progress - ST 3"; |
| } | | |
| | | |
| typedef Bgp-gshut-bw-edm-state { | | |
| type enumeration { | | |
| enum "bgp-gshut-bw-edm-state-init" { | | |
| value 0; | | |
| description | | |
| "Not Configured"; | | |
| } | | |
| enum "bgp-gshut-bw-edm-state-validate" { | | |
| value 1; | | |
| description | | |
| "Validating Update"; | | |
| } | | |
| enum "bgp-gshut-bw-edm-state-no-op" { | | |
| value 2; | | |
| description | | |
| "Non Operational"; | | |
| } | | |
| enum "bgp-gshut-bw-edm-state-learn" { | | |
| value 3; | | |
| description | | |
| "Learning from Interface"; | | |
| } | | |
| enum "bgp-gshut-bw-edm-state-compute" { | | |
| value 4; | | |
| description | | |
| "Processing"; | | |
| } | | |
| enum "bgp-gshut-bw-edm-state-active" { | | |
| value 5; | | |
| description | | |
| "Graceful-Maintenance Active"; | | |
| } | | |
| enum "bgp-gshut-bw-edm-state-inactive" { | | |
| value 6; | | |
| description | | |
| "Inactive as Bandwidth threshold met"; | | |
| } | | |
| enum "bgp-gshut-bw-edm-state-max" { | | |
| value 7; | | |
| description | | |
| "Invalid State"; | | |
| } | | |
| } | | } |
| | | enum "bgp-nbr-nsr-st-bgp-init-sync" { |
| description | | description |
| "Bgp gshut bw edm state"; | | "BGP initial sync in progress - ST 4"; |
| } | | |
| | | |
| typedef Bgp-slow-peer-state { | | |
| type enumeration { | | |
| enum "bgp-s-low-peer-none-state" { | | |
| value 0; | | |
| description | | |
| "Slow peer is none"; | | |
| } | | |
| enum "bgp-s-low-peer-static-state" { | | |
| value 1; | | |
| description | | |
| "Slow peer is static"; | | |
| } | | |
| enum "bgp-s-low-peer-dynamic-state" { | | |
| value 2; | | |
| description | | |
| "Slow peer is dynamic"; | | |
| } | | |
| enum "bgp-s-low-peer-detection-only-state" { | | |
| value 3; | | |
| description | | |
| "Slow peer is detection-only"; | | |
| } | | |
| } | | } |
| | | enum "bgp-nbr-nsr-st-nsr-ready" { |
| description | | description |
| "BGP slow peer state"; | | "Neighbor NSR ready - ST 5"; |
| | | } |
| } | | } |
| | | |
| typedef Bgp-track-state { | | |
| type enumeration { | | |
| enum "bgp-track-state-unknown" { | | |
| value 0; | | |
| description | | description |
| "Track state is Unknown"; | | "Bgp sync nbr nsr state"; |
| } | | |
| enum "bgp-track-state-down" { | | |
| value 1; | | |
| description | | |
| "Track state is Down"; | | |
| } | | |
| enum "bgp-track-state-up" { | | |
| value 2; | | |
| description | | |
| "Track state is Up"; | | |
| } | | |
| } | | |
| description | | |
| "BGP Track state"; | | |
| } | | } |
| | | |
| typedef Bgp-peer-reset-reason-index { | | typedef Bgp-peer-reset-reason-index { |
| type enumeration { | | type enumeration { |
| enum "bgp-read-remote-closed" { | | enum "bgp-read-remote-closed" { |
| value 1; | | value 1; |
| description | | description |
| "Remote closed the session"; | | "Remote closed the session"; |
| } | | } |
| enum "bgp-read-failed" { | | enum "bgp-read-failed" { |
| value 2; | | value 2; |
| description | | description |
| "Read failed"; | | "Read failed"; |
| } | | } |
| enum "bgp-write-failed" { | | enum "bgp-write-failed" { |
| value 3; | | value 3; |
| description | | description |
| "Write failed"; | | "Write failed"; |
| } | | } |
| enum "bgp-sock-disconnected" { | | enum "bgp-sock-disconnected" { |
| value 4; | | value 4; |
| description | | description |
| "Socket disconnected"; | | "Socket disconnected"; |
| } | | } |
| enum "bgp-sock-select-failed" { | | enum "bgp-sock-select-failed" { |
| value 5; | | value 5; |
| description | | description |
| "Socket select failed"; | | "Socket select failed"; |
| } | | } |
| enum "bgp-peer-reset-reason-none" { | | enum "bgp-peer-reset-reason-none" { |
| value 6; | | value 6; |
| description | | description |
| "None"; | | "None"; |
| } | | } |
| } | | } |
| description | | description |
| "Bgp peer reset reason index"; | | "Bgp peer reset reason index"; |
| } | | } |
| | | |
| typedef Bgp-reset-reason-index { | | typedef Bgp-reset-reason-index { |
| type enumeration { | | type enumeration { |
| enum "bgp-none" { | | enum "bgp-none" { |
| value 0; | | value 0; |
| description | | description |
| "None"; | | "None"; |
| } | | } |
| enum "bgp-init" { | | enum "bgp-init" { |
| value 1; | | value 1; |
| description | | description |
| "BGP neighbor initialized"; | | "BGP neighbor initialized"; |
| } | | } |
| enum "bgp-no-memory" { | | enum "bgp-no-memory" { |
| value 2; | | value 2; |
| description | | description |
| "No memory"; | | "No memory"; |
| } | | } |
| enum "not-received" { | | enum "not-received" { |
| value 3; | | value 3; |
| description | | description |
| "BGP Notification received"; | | "BGP Notification received"; |
| } | | } |
| enum "not-sent" { | | enum "not-sent" { |
| value 4; | | value 4; |
| description | | description |
| "BGP Notification sent"; | | "BGP Notification sent"; |
| } | | } |
| enum "conn-collision" { | | enum "conn-collision" { |
| value 5; | | value 5; |
| description | | description |
| "Error during connection collision"; | | "Error during connection collision"; |
| } | | } |
| enum "peer-closed" { | | enum "peer-closed" { |
| value 6; | | value 6; |
| description | | description |
| "Peer closing down the session"; | | "Peer closing down the session"; |
| } | | } |
| enum "max-prefix-exceeded" { | | enum "max-prefix-exceeded" { |
| value 7; | | value 7; |
| description | | description |
| "Peer exceeding maximum prefix limit"; | | "Peer exceeding maximum prefix limit"; |
| } | | } |
| enum "interface-flap" { | | enum "interface-flap" { |
| value 8; | | value 8; |
| description | | description |
| "Interface flap"; | | "Interface flap"; |
| } | | } |
| enum "neighbor-deleted" { | | enum "neighbor-deleted" { |
| value 9; | | value 9; |
| description | | description |
| "Neighbor deleted"; | | "Neighbor deleted"; |
| } | | } |
| enum "admin-shutdown" { | | enum "admin-shutdown" { |
| value 10; | | value 10; |
| description | | description |
| "Admin. shutdown"; | | "Admin. shutdown"; |
| } | | } |
| enum "af-activated" { | | enum "af-activated" { |
| value 11; | | value 11; |
| description | | description |
| "Address family activated"; | | "Address family activated"; |
| } | | } |
| enum "af-deactivated" { | | enum "af-deactivated" { |
| value 12; | | value 12; |
| description | | description |
| "Address family removed"; | | "Address family removed"; |
| } | | } |
| enum "protocol-error" { | | enum "protocol-error" { |
| value 13; | | value 13; |
| description | | description |
| "Protocol Error"; | | "Protocol Error"; |
| } | | } |
| enum "listen-closed" { | | enum "listen-closed" { |
| value 14; | | value 14; |
| description | | description |
| "Listen socket was closed"; | | "Listen socket was closed"; |
| } | | } |
| enum "rib-failed" { | | enum "rib-failed" { |
| value 15; | | value 15; |
| description | | description |
| "Routing Table process not responding"; | | "Routing Table process not responding"; |
| } | | } |
| enum "user-clear" { | | enum "user-clear" { |
| value 16; | | value 16; |
| description | | description |
| "User clear requested"; | | "User clear requested"; |
| } | | } |
| enum "user-clear-gr" { | | enum "user-clear-gr" { |
| value 17; | | value 17; |
| description | | description |
| "User clear with graceful restart requested"; | | "User clear with graceful restart requested"; |
| } | | } |
| enum "router-id-changed" { | | enum "router-id-changed" { |
| value 18; | | value 18; |
| description | | description |
| "Router ID changed"; | | "Router ID changed"; |
| } | | } |
| enum "remote-as-changed" { | | enum "remote-as-changed" { |
| value 19; | | value 19; |
| description | | description |
| "Remote AS configuration changed"; | | "Remote AS configuration changed"; |
| } | | } |
| enum "orf-changed" { | | enum "orf-changed" { |
| value 20; | | value 20; |
| description | | description |
| "Outbound route filter configuration changed"; | | "Outbound route filter configuration changed"; |
| } | | } |
| enum "rr-client-changed" { | | enum "rr-client-changed" { |
| value 21; | | value 21; |
| description | | description |
| "RR client configuration changed"; | | "RR client configuration changed"; |
| } | | } |
| enum "legacy-pe-rt-changed" { | | enum "legacy-pe-rt-changed" { |
| value 22; | | value 22; |
| description | | description |
| "Legacy-pe-RT configuration changed"; | | "Legacy-pe-RT configuration changed"; |
| } | | } |
| enum "softre-config-changed" { | | enum "softre-config-changed" { |
| value 23; | | value 23; |
| description | | description |
| "Soft reconfiguration configuration changed"; | | "Soft reconfiguration configuration changed"; |
| } | | } |
| enum "local-as-changed" { | | enum "local-as-changed" { |
| value 24; | | value 24; |
| description | | description |
| "Local AS configuration changed"; | | "Local AS configuration changed"; |
| } | | } |
| enum "low-memory" { | | enum "low-memory" { |
| value 25; | | value 25; |
| description | | description |
| "Shutdown during SEVERE low memory condition"; | | "Shutdown during SEVERE low memory condition"; |
| } | | } |
| enum "bfd-down" { | | enum "bfd-down" { |
| value 26; | | value 26; |
| description | | description |
| "BFD (Bidirectional forwarding detection) | | "BFD (Bidirectional forwarding detection) |
| session down"; | | session down"; |
| } | | } |
| enum "allow-as-in-changed" { | | enum "allow-as-in-changed" { |
| value 27; | | value 27; |
| description | | description |
| "Allowas-in configuration has changed"; | | "Allowas-in configuration has changed"; |
| } | | } |
| n | enum "allow-confedas-in-changed" { | n | enum "recv-dmz-cfg" { |
| value 28; | | value 28; |
| description | | description |
| n | "Allowconfedas-in configuration has changed"; | n | "Recv DMZ Config changed"; |
| } | | } |
| n | enum "recv-dmz-cfg" { | n | enum "cap-4byteas-changed" { |
| value 29; | | value 29; |
| description | | description |
| n | "Recv DMZ Config changed"; | n | "Capablity 4-byte-as configuration has changed"; |
| } | | } |
| n | enum "cap-4byteas-changed" { | n | enum "tcp-oper-down" { |
| value 30; | | value 30; |
| description | | description |
| n | "Capablity 4-byte-as configuration has changed"; | n | "Received tcp oper down"; |
| } | | } |
| n | enum "tcp-oper-down" { | n | enum "scoped-sync-retry" { |
| value 31; | | value 31; |
| description | | description |
| n | "Received tcp oper down"; | n | "Scoped sync is repeated due to strict |
| | | prefix check failure"; |
| } | | } |
| n | enum "scoped-sync-retry" { | n | enum "cluster-id-changed" { |
| value 32; | | value 32; |
| description | | description |
| n | "Scoped sync is repeated due to strict prefix | n | "Neighbor moved to a new cluster"; |
| check failure"; | | |
| } | | } |
| n | enum "cluster-id-changed" { | n | enum "rr-disable-changed" { |
| value 33; | | value 33; |
| n | description | n | |
| "Neighbor moved to a new cluster"; | | |
| } | | |
| enum "rr-disable-changed" { | | |
| value 34; | | |
| description | | description |
| "Client-to-client reflection disabled/enabled | | "Client-to-client reflection disabled/enabled |
| for cluster to which neighbor belongs"; | | for cluster to which neighbor belongs"; |
| } | | } |
| enum "aigp-changed" { | | enum "aigp-changed" { |
| n | | n | value 34; |
| | | description |
| | | "AIGP configuration has changed |
| | | for cluster to which neighbor belongs"; |
| | | } |
| | | enum "signalling-changed" { |
| value 35; | | value 35; |
| description | | description |
| n | "AIGP configuration has changed for cluster to | n | "L2VPN Signalling Changed"; |
| which neighbor belongs"; | | |
| } | | } |
| n | enum "signalling-changed" { | n | enum "open-check-s-failed" { |
| value 36; | | value 36; |
| description | | description |
| n | "L2VPN Signalling Changed"; | n | "Session open checks failed"; |
| } | | } |
| n | enum "open-check-s-failed" { | n | enum "ao-changed" { |
| value 37; | | value 37; |
| description | | description |
| n | "Session open checks failed"; | n | "Accept-own changed"; |
| } | | } |
| n | enum "ao-changed" { | n | enum "llgr-staletime-changed" { |
| value 38; | | value 38; |
| n | description | n | |
| "Accept-own changed"; | | |
| } | | |
| enum "llgr-staletime-changed" { | | |
| value 39; | | |
| description | | description |
| "Long-lived graceful-restart stale-time | | "Long-lived graceful-restart stale-time |
| configuration changed"; | | configuration changed"; |
| } | | } |
| enum "llgr-capable-changed" { | | enum "llgr-capable-changed" { |
| n | value 40; | n | value 39; |
| description | | description |
| "Long-lived graceful-restart capable | | "Long-lived graceful-restart capable |
| configuration changed"; | | configuration changed"; |
| } | | } |
| enum "nbr-local-addr-changed" { | | enum "nbr-local-addr-changed" { |
| n | | n | value 40; |
| | | description |
| | | "Neighbor local address configuration changed"; |
| | | } |
| | | enum "internal-vpn-client-changed" { |
| value 41; | | value 41; |
| description | | description |
| n | "Neighbor local address configuration changed"; | n | "Internal-vpn-client configuration changed"; |
| } | | } |
| n | enum "internal-vpn-client-changed" { | n | enum "cap-suppress-all-changed" { |
| value 42; | | value 42; |
| description | | description |
| n | "Internal-vpn-client configuration changed"; | n | "All capabilities suppression changed"; |
| } | | } |
| n | enum "cap-suppress-all-changed" { | n | enum "next-hop-changed" { |
| value 43; | | value 43; |
| description | | description |
| n | "All capabilities suppression changed"; | n | |
| } | | |
| enum "next-hop-changed" { | | |
| value 44; | | |
| description | | |
| "Next hop configuration changed"; | | "Next hop configuration changed"; |
| n | } | n | |
| enum "cap-suppress-enhe-changed" { | | |
| value 45; | | |
| description | | |
| "Extended-nexthop-encoding capability | | |
| suppression changed"; | | |
| } | | } |
| } | | } |
| description | | description |
| "Bgp reset reason index"; | | "Bgp reset reason index"; |
| } | | } |
| | | |
| typedef Bgp-bfd-enable-mode { | | typedef Bgp-bfd-enable-mode { |
| type enumeration { | | type enumeration { |
| enum "bgp-bfd-enable-mode-disable" { | | enum "bgp-bfd-enable-mode-disable" { |
| value 0; | | value 0; |
| description | | description |
| "BFD fast detect disabled "; | | "BFD fast detect disabled "; |
| } | | } |
| enum "bgp-bfd-enable-mode-def" { | | enum "bgp-bfd-enable-mode-def" { |
| value 1; | | value 1; |
| description | | description |
| "BFD fast detect default mode "; | | "BFD fast detect default mode "; |
| } | | } |
| enum "bgp-bfd-enable-mode-strict" { | | enum "bgp-bfd-enable-mode-strict" { |
| value 2; | | value 2; |
| description | | description |
| "BFD fast detect hold down aka strict mode"; | | "BFD fast detect hold down aka strict mode"; |
| } | | } |
| } | | } |
| description | | description |
| "BFD enable mode"; | | "BFD enable mode"; |
| } | | } |
| | | |
| typedef Bgp-bfd-state { | | typedef Bgp-bfd-state { |
| type enumeration { | | type enumeration { |
| enum "bgp-bfd-state-not-configured" { | | enum "bgp-bfd-state-not-configured" { |
| value 0; | | value 0; |
| description | | description |
| "BFD not configured"; | | "BFD not configured"; |
| } | | } |
| enum "bgp-bfd-state-admin-down" { | | enum "bgp-bfd-state-admin-down" { |
| value 1; | | value 1; |
| description | | description |
| "BFD session disabled (neighbor shutdown)"; | | "BFD session disabled (neighbor shutdown)"; |
| } | | } |
| enum "bgp-bfd-state-not-supported" { | | enum "bgp-bfd-state-not-supported" { |
| value 2; | | value 2; |
| description | | description |
| "BFD session disabled (interface type not | | "BFD session disabled (interface type not |
| supported)"; | | supported)"; |
| } | | } |
| enum "bgp-bfd-state-not-created" { | | enum "bgp-bfd-state-not-created" { |
| value 3; | | value 3; |
| description | | description |
| "BFD session configured, not yet created"; | | "BFD session configured, not yet created"; |
| } | | } |
| enum "bgp-bfd-state-created" { | | enum "bgp-bfd-state-created" { |
| value 4; | | value 4; |
| description | | description |
| "BFD session created, state notification not | | "BFD session created, state notification not |
| received"; | | received"; |
| } | | } |
| enum "bgp-bfd-state-up" { | | enum "bgp-bfd-state-up" { |
| value 5; | | value 5; |
| description | | description |
| "BFD session up"; | | "BFD session up"; |
| } | | } |
| enum "bgp-bfd-state-down" { | | enum "bgp-bfd-state-down" { |
| value 6; | | value 6; |
| description | | description |
| "BFD session down"; | | "BFD session down"; |
| } | | } |
| enum "bgp-bfd-state-nbr-not-configured" { | | enum "bgp-bfd-state-nbr-not-configured" { |
| value 7; | | value 7; |
| description | | description |
| "BFD session down (peer not configured)"; | | "BFD session down (peer not configured)"; |
| } | | } |
| enum "bgp-bfd-state-none" { | | enum "bgp-bfd-state-none" { |
| value 8; | | value 8; |
| description | | description |
| "BFD session (yet ro rcv Notification)"; | | "BFD session (yet ro rcv Notification)"; |
| } | | } |
| } | | } |
| description | | description |
| "BFD session state"; | | "BFD session state"; |
| } | | } |
| | | |
| typedef Bgp-open-check-err { | | typedef Bgp-open-check-err { |
| type enumeration { | | type enumeration { |
| enum "none" { | | enum "none" { |
| value 0; | | value 0; |
| description | | description |
| "No error"; | | "No error"; |
| } | | } |
| enum "neighbor-down" { | | enum "neighbor-down" { |
| value 1; | | value 1; |
| description | | description |
| "Neighbor down"; | | "Neighbor down"; |
| } | | } |
| enum "no-update-group-set" { | | enum "no-update-group-set" { |
| value 2; | | value 2; |
| description | | description |
| "No update-group set"; | | "No update-group set"; |
| } | | } |
| enum "no-af-config" { | | enum "no-af-config" { |
| value 3; | | value 3; |
| description | | description |
| "No AF configured"; | | "No AF configured"; |
| } | | } |
| enum "update-group-pending" { | | enum "update-group-pending" { |
| value 4; | | value 4; |
| description | | description |
| "Update-group pending"; | | "Update-group pending"; |
| } | | } |
| enum "low-memory" { | | enum "low-memory" { |
| value 5; | | value 5; |
| description | | description |
| "Low memory"; | | "Low memory"; |
| } | | } |
| enum "neighbor-shutdown" { | | enum "neighbor-shutdown" { |
| value 6; | | value 6; |
| description | | description |
| "Neighbor shutdown"; | | "Neighbor shutdown"; |
| } | | } |
| enum "ebgp-neighbor-remote" { | | enum "ebgp-neighbor-remote" { |
| value 7; | | value 7; |
| description | | description |
| "eBGP neighbor is remote"; | | "eBGP neighbor is remote"; |
| } | | } |
| enum "update-source-interface-null" { | | enum "update-source-interface-null" { |
| value 8; | | value 8; |
| description | | description |
| "Update source invalid"; | | "Update source invalid"; |
| } | | } |
| enum "no-ipv6-address" { | | enum "no-ipv6-address" { |
| value 9; | | value 9; |
| description | | description |
| "No global IPv6 address found"; | | "No global IPv6 address found"; |
| } | | } |
| enum "first-hop-interface-null" { | | enum "first-hop-interface-null" { |
| value 10; | | value 10; |
| description | | description |
| "First-hop interface invalid"; | | "First-hop interface invalid"; |
| } | | } |
| enum "no-ipv6ll-address" { | | enum "no-ipv6ll-address" { |
| value 11; | | value 11; |
| description | | description |
| "No LL IPv6 address found"; | | "No LL IPv6 address found"; |
| } | | } |
| enum "no-update-source-config" { | | enum "no-update-source-config" { |
| value 12; | | value 12; |
| description | | description |
| "No update-source configured"; | | "No update-source configured"; |
| } | | } |
| enum "no-router-id" { | | enum "no-router-id" { |
| value 13; | | value 13; |
| description | | description |
| "No router-identifier"; | | "No router-identifier"; |
| } | | } |
| enum "update-source-interface-get-failed" { | | enum "update-source-interface-get-failed" { |
| value 14; | | value 14; |
| description | | description |
| "Update-source interface get failed"; | | "Update-source interface get failed"; |
| } | | } |
| enum "update-source-interface-state-get-failed" { | | enum "update-source-interface-state-get-failed" { |
| value 15; | | value 15; |
| description | | description |
| "Update-source interface state get failed"; | | "Update-source interface state get failed"; |
| } | | } |
| enum "update-source-interface-down" { | | enum "update-source-interface-down" { |
| value 16; | | value 16; |
| description | | description |
| "Update-source interface down"; | | "Update-source interface down"; |
| } | | } |
| enum "update-source-interface-ll-get-failed" { | | enum "update-source-interface-ll-get-failed" { |
| value 17; | | value 17; |
| description | | description |
| "Update-source interface LL get failed"; | | "Update-source interface LL get failed"; |
| } | | } |
| enum "update-source-interface-address-get-failed" { | | enum "update-source-interface-address-get-failed" { |
| value 18; | | value 18; |
| description | | description |
| "Update-source interface address get failed"; | | "Update-source interface address get failed"; |
| } | | } |
| enum "source-address-af-invalid" { | | enum "source-address-af-invalid" { |
| value 19; | | value 19; |
| description | | description |
| "Source-address AF invalid"; | | "Source-address AF invalid"; |
| } | | } |
| enum "no-update-source-ll-peering" { | | enum "no-update-source-ll-peering" { |
| value 20; | | value 20; |
| description | | description |
| "No update-source for LL peering"; | | "No update-source for LL peering"; |
| } | | } |
| enum "local-address-get-failed" { | | enum "local-address-get-failed" { |
| value 21; | | value 21; |
| description | | description |
| "Local-address get failed"; | | "Local-address get failed"; |
| } | | } |
| enum "no-best-local-address" { | | enum "no-best-local-address" { |
| value 22; | | value 22; |
| description | | description |
| "No best local-address"; | | "No best local-address"; |
| } | | } |
| enum "neighbor-address-equals-local-address" { | | enum "neighbor-address-equals-local-address" { |
| value 23; | | value 23; |
| description | | description |
| "Neighbor address is local address"; | | "Neighbor address is local address"; |
| } | | } |
| enum "neighbor-closing" { | | enum "neighbor-closing" { |
| value 24; | | value 24; |
| description | | description |
| "Neighbor in closing state"; | | "Neighbor in closing state"; |
| } | | } |
| enum "neighbor-pending-reset" { | | enum "neighbor-pending-reset" { |
| value 25; | | value 25; |
| description | | description |
| "Neighbor in pending reset state"; | | "Neighbor in pending reset state"; |
| } | | } |
| enum "out-interface-set-failed" { | | enum "out-interface-set-failed" { |
| value 26; | | value 26; |
| description | | description |
| "Out-interface set failed"; | | "Out-interface set failed"; |
| } | | } |
| enum "local-address-mismatch" { | | enum "local-address-mismatch" { |
| value 27; | | value 27; |
| description | | description |
| "Local-address mismatch"; | | "Local-address mismatch"; |
| } | | } |
| enum "neighbor-active-only" { | | enum "neighbor-active-only" { |
| value 28; | | value 28; |
| description | | description |
| "Neighbor in active only mode"; | | "Neighbor in active only mode"; |
| } | | } |
| enum "socket-init-failed" { | | enum "socket-init-failed" { |
| value 29; | | value 29; |
| description | | description |
| "Socket init failed"; | | "Socket init failed"; |
| } | | } |
| enum "socket-operation-failed" { | | enum "socket-operation-failed" { |
| value 30; | | value 30; |
| description | | description |
| "Socket operation failed"; | | "Socket operation failed"; |
| } | | } |
| enum "local-neighbor" { | | enum "local-neighbor" { |
| value 31; | | value 31; |
| description | | description |
| "Neighbor is local"; | | "Neighbor is local"; |
| } | | } |
| enum "multi-hop-neighbor" { | | enum "multi-hop-neighbor" { |
| value 32; | | value 32; |
| description | | description |
| "No router to multi-hop neighbor"; | | "No router to multi-hop neighbor"; |
| } | | } |
| } | | } |
| description | | description |
| "BGP open check error types"; | | "BGP open check error types"; |
| } | | } |
| | | |
| n | typedef Bgp-bmp-mode { | n | typedef Bgp-conn-state { |
| type enumeration { | | type enumeration { |
| n | enum "inbound-pre-policy" { | n | enum "bgp-st-dont-care" { |
| value 0; | | value 0; |
| description | | description |
| n | "BMP inbound pre policy"; | n | "DontCare"; |
| } | | } |
| n | enum "inbound-post-policy" { | n | enum "bgp-st-idle" { |
| value 1; | | value 1; |
| description | | description |
| n | "BMP inbound post policy"; | n | "Idle"; |
| } | | } |
| n | enum "mode-out-pre" { | n | enum "bgp-st-connect" { |
| value 2; | | value 2; |
| description | | description |
| n | "BMP outbound pre policy"; | n | "Connect"; |
| } | | } |
| n | enum "mode-out-post" { | n | enum "bgp-st-active" { |
| value 3; | | value 3; |
| description | | description |
| n | "BMP outbound post policy"; | n | "Active"; |
| } | | } |
| n | enum "local-rib" { | n | enum "bgp-st-open-sent" { |
| value 4; | | value 4; |
| description | | description |
| n | "BMP local rib"; | n | "OpenSent"; |
| } | | |
| } | | } |
| | | enum "bgp-st-open-confirm" { |
| | | value 5; |
| description | | description |
| "BGP BMP mode type"; | | "OpenConfirm"; |
| | | } |
| | | enum "bgp-st-estab" { |
| | | value 6; |
| | | description |
| | | "Established"; |
| | | } |
| | | enum "bgp-st-closing" { |
| | | value 7; |
| | | description |
| | | "Closing"; |
| | | } |
| | | enum "bgp-st-closing-sync" { |
| | | value 8; |
| | | description |
| | | "ClosingSync"; |
| | | } |
| | | } |
| | | description |
| | | "Bgp conn state"; |
| } | | } |
| | | |
| typedef Bgp-nh-validate { | | typedef Bgp-nh-validate { |
| type enumeration { | | type enumeration { |
| enum "bgp-nh-validate-sync" { | | enum "bgp-nh-validate-sync" { |
| description | | description |
| "bgp nh validate sync"; | | "bgp nh validate sync"; |
| } | | } |
| enum "bgp-nh-validate-async" { | | enum "bgp-nh-validate-async" { |
| description | | description |
| "bgp nh validate async"; | | "bgp nh validate async"; |
| } | | } |
| enum "bgp-nh-validate-none" { | | enum "bgp-nh-validate-none" { |
| description | | description |
| "bgp nh validate none"; | | "bgp nh validate none"; |
| } | | } |
| } | | } |
| description | | description |
| "Bgp nh validate"; | | "Bgp nh validate"; |
| } | | } |
| | | |
| typedef Bgp-nh-update { | | typedef Bgp-nh-update { |
| type enumeration { | | type enumeration { |
| enum "bgp-nh-update-none" { | | enum "bgp-nh-update-none" { |
| value 0; | | value 0; |
| description | | description |
| "No nh update yet"; | | "No nh update yet"; |
| } | | } |
| enum "bgp-nh-update-crit-not-f" { | | enum "bgp-nh-update-crit-not-f" { |
| value 1; | | value 1; |
| description | | description |
| "Last nh update is crit notf"; | | "Last nh update is crit notf"; |
| } | | } |
| enum "bgp-nh-update-crit-sync" { | | enum "bgp-nh-update-crit-sync" { |
| value 2; | | value 2; |
| description | | description |
| "Last nh update is crit sync update"; | | "Last nh update is crit sync update"; |
| } | | } |
| enum "bgp-nh-update-crit-rib-conv" { | | enum "bgp-nh-update-crit-rib-conv" { |
| value 3; | | value 3; |
| description | | description |
| "Last nh update is crit update caused by rib | | "Last nh update is crit update caused by rib |
| converge"; | | converge"; |
| } | | } |
| enum "bgp-nh-update-crit-table-down" { | | enum "bgp-nh-update-crit-table-down" { |
| value 4; | | value 4; |
| description | | description |
| "Last nh update is crit update caused by table | | "Last nh update is crit update caused by table |
| down"; | | down"; |
| } | | } |
| enum "bgp-nh-update-non-crit-not-f" { | | enum "bgp-nh-update-non-crit-not-f" { |
| value 5; | | value 5; |
| description | | description |
| "Last nh update is non-crit notf"; | | "Last nh update is non-crit notf"; |
| } | | } |
| enum "bgp-nh-update-non-crit-sync" { | | enum "bgp-nh-update-non-crit-sync" { |
| value 6; | | value 6; |
| description | | description |
| "Last nh update is non-crit sync update"; | | "Last nh update is non-crit sync update"; |
| } | | } |
| enum "bgp-nh-update-non-crit-rib-conv" { | | enum "bgp-nh-update-non-crit-rib-conv" { |
| value 7; | | value 7; |
| description | | description |
| "Last nh update is non-crit update caused by rib | | "Last nh update is non-crit update caused by rib |
| converge"; | | converge"; |
| } | | } |
| enum "bgp-nh-update-non-crit-table-down" { | | enum "bgp-nh-update-non-crit-table-down" { |
| value 8; | | value 8; |
| description | | description |
| "Last nh update is non-crit update caused by | | "Last nh update is non-crit update caused by |
| table down"; | | table down"; |
| } | | } |
| } | | } |
| description | | description |
| "Bgp nh update"; | | "Bgp nh update"; |
| } | | } |
| | | |
| typedef Bgp-nh-event { | | typedef Bgp-nh-event { |
| type enumeration { | | type enumeration { |
| enum "bgp-nh-event-crit-not-f" { | | enum "bgp-nh-event-crit-not-f" { |
| value 0; | | value 0; |
| description | | description |
| "Last event received is a crit notf"; | | "Last event received is a crit notf"; |
| } | | } |
| enum "bgp-nh-event-non-crit-not-f" { | | enum "bgp-nh-event-non-crit-not-f" { |
| value 1; | | value 1; |
| description | | description |
| "Last event received is a non-crit notf"; | | "Last event received is a non-crit notf"; |
| } | | } |
| enum "bgp-nh-event-registration" { | | enum "bgp-nh-event-registration" { |
| value 2; | | value 2; |
| description | | description |
| "Last event sent is a registration"; | | "Last event sent is a registration"; |
| } | | } |
| } | | } |
| description | | description |
| "Bgp nh event"; | | "Bgp nh event"; |
| } | | } |
| | | |
| n | typedef Bgp-usid-alloc-mode { | n | |
| type enumeration { | | |
| enum "bgp-usid-alloc-default" { | | |
| value 0; | | |
| description | | |
| "Default SRv6 uSID allocation mode"; | | |
| } | | |
| enum "bgp-usid-alloc-wlib-only" { | | |
| value 1; | | |
| description | | |
| "SRv6 uSID WLIB only allocation"; | | |
| } | | |
| enum "bgp-usid-alloc-wlib-fallback" { | | |
| value 2; | | |
| description | | |
| "SRv6 uSID WLIB fallback allocation"; | | |
| } | | |
| } | | |
| description | | |
| "Bgp usid alloc mode"; | | |
| } | | |
| | | |
| typedef Bgp-vr-bumpcount-event { | | |
| type enumeration { | | |
| enum "bgp-other" { | | |
| value 0; | | |
| description | | |
| "Other"; | | |
| } | | |
| enum "bgp-reachable" { | | |
| value 1; | | |
| description | | |
| "Reachable"; | | |
| } | | |
| enum "bgp-unreachable" { | | |
| value 2; | | |
| description | | |
| "Unreachable"; | | |
| } | | |
| enum "bgp-import" { | | |
| value 3; | | |
| description | | |
| "Import"; | | |
| } | | |
| enum "bgp-redist" { | | |
| value 4; | | |
| description | | |
| "Redistributed"; | | |
| } | | |
| enum "bgp-label" { | | |
| value 5; | | |
| description | | |
| "Label"; | | |
| } | | |
| enum "bgp-next-hop" { | | |
| value 6; | | |
| description | | |
| "Nexthop"; | | |
| } | | |
| } | | |
| description | | |
| "Bgp vr bumpcount event"; | | |
| } | | |
| | | |
| typedef Bgp-rtr-state { | | typedef Bgp-rtr-state { |
| type enumeration { | | type enumeration { |
| enum "bgp-router-read-only" { | | enum "bgp-router-read-only" { |
| value 0; | | value 0; |
| description | | description |
| "Read only mode"; | | "Read only mode"; |
| } | | } |
| enum "bgp-router-do-best-path" { | | enum "bgp-router-do-best-path" { |
| value 1; | | value 1; |
| description | | description |
| "Bestpath calculation mode"; | | "Bestpath calculation mode"; |
| } | | } |
| enum "bgp-router-do-tunnel-update" { | | enum "bgp-router-do-tunnel-update" { |
| value 2; | | value 2; |
| description | | description |
| "Tunnel update mode"; | | "Tunnel update mode"; |
| } | | } |
| enum "bgp-router-do-import" { | | enum "bgp-router-do-import" { |
| value 3; | | value 3; |
| description | | description |
| "Import mode"; | | "Import mode"; |
| } | | } |
| enum "bgp-router-do-label-alloc" { | | enum "bgp-router-do-label-alloc" { |
| value 4; | | value 4; |
| description | | description |
| "Label Allocation mode"; | | "Label Allocation mode"; |
| } | | } |
| enum "bgp-router-do-ribupd" { | | enum "bgp-router-do-ribupd" { |
| value 5; | | value 5; |
| description | | description |
| "RIB update mode"; | | "RIB update mode"; |
| } | | } |
| enum "bgp-router-read-write" { | | enum "bgp-router-read-write" { |
| value 6; | | value 6; |
| description | | description |
| "Normal (read/write) mode"; | | "Normal (read/write) mode"; |
| } | | } |
| enum "bgp-router-mode-count" { | | enum "bgp-router-mode-count" { |
| value 7; | | value 7; |
| description | | description |
| "Number of router modes"; | | "Number of router modes"; |
| } | | } |
| } | | } |
| description | | description |
| "Bgp rtr state"; | | "Bgp rtr state"; |
| } | | } |
| | | |
| n | | n | typedef Mac-address { |
| | | type yang:mac-address; |
| | | description |
| | | "MAC Address type"; |
| | | } |
| | | |
| typedef Bgp-rnh-addr-len { | | typedef Bgp-rnh-addr-len { |
| type enumeration { | | type enumeration { |
| enum "none" { | | enum "none" { |
| value 0; | | value 0; |
| description | | description |
| "NO address length"; | | "NO address length"; |
| } | | } |
| enum "v4" { | | enum "v4" { |
| value 4; | | value 4; |
| description | | description |
| "IP v4 address length"; | | "IP v4 address length"; |
| } | | } |
| enum "mac" { | | enum "mac" { |
| value 6; | | value 6; |
| description | | description |
| "MAC address length"; | | "MAC address length"; |
| } | | } |
| enum "v6" { | | enum "v6" { |
| value 16; | | value 16; |
| description | | description |
| "IP v6 address length"; | | "IP v6 address length"; |
| } | | } |
| } | | } |
| description | | description |
| "BGP RNH Address Length"; | | "BGP RNH Address Length"; |
| } | | } |
| | | |
| typedef Sr-sid { | | typedef Sr-sid { |
| type enumeration { | | type enumeration { |
| enum "label" { | | enum "label" { |
| value 1; | | value 1; |
| description | | description |
| "MPLS Label sid"; | | "MPLS Label sid"; |
| } | | } |
| enum "ipv4" { | | enum "ipv4" { |
| value 2; | | value 2; |
| description | | description |
| "IPv4 address"; | | "IPv4 address"; |
| } | | } |
| enum "ipv6" { | | enum "ipv6" { |
| value 3; | | value 3; |
| description | | description |
| "IPv6 address"; | | "IPv6 address"; |
| } | | } |
| } | | } |
| description | | description |
| "Segment id type"; | | "Segment id type"; |
| } | | } |
| | | |
| typedef Bgp-srpolicy-req-state { | | typedef Bgp-srpolicy-req-state { |
| type enumeration { | | type enumeration { |
| enum "request-pending" { | | enum "request-pending" { |
| value 0; | | value 0; |
| description | | description |
| "SR policy install in dataplane not requested | | "SR policy install in dataplane not requested |
| yet"; | | yet"; |
| } | | } |
| enum "requested" { | | enum "requested" { |
| value 1; | | value 1; |
| description | | description |
| "Requested SR policy install dataplane"; | | "Requested SR policy install dataplane"; |
| } | | } |
| enum "notified-up" { | | enum "notified-up" { |
| value 2; | | value 2; |
| description | | description |
| "SR policy is UP"; | | "SR policy is UP"; |
| } | | } |
| enum "notified-down" { | | enum "notified-down" { |
| value 4; | | value 4; |
| description | | description |
| "SR policy is notified down by XTC"; | | "SR policy is notified down by XTC"; |
| } | | } |
| enum "marked-stale" { | | enum "marked-stale" { |
| value 8; | | value 8; |
| description | | description |
| "SR policy is marked stale due to XTC agent down"; | | "SR policy is marked stale due to XTC agent down"; |
| } | | } |
| enum "marked-disable" { | | enum "marked-disable" { |
| value 16; | | value 16; |
| description | | description |
| "SR policy is marked disabled from the config in | | "SR policy is marked disabled from the config in |
| XTC"; | | XTC"; |
| } | | } |
| } | | } |
| description | | description |
| "BGP SR Policy Internal State"; | | "BGP SR Policy Internal State"; |
| } | | } |
| | | |
| typedef Bgp-binding-sid { | | typedef Bgp-binding-sid { |
| type enumeration { | | type enumeration { |
| enum "none" { | | enum "none" { |
| value 0; | | value 0; |
| description | | description |
| "None"; | | "None"; |
| } | | } |
| enum "label" { | | enum "label" { |
| value 1; | | value 1; |
| description | | description |
| "Binding SID type MPLS label"; | | "Binding SID type MPLS label"; |
| } | | } |
| enum "v6" { | | enum "v6" { |
| value 2; | | value 2; |
| description | | description |
| "Binding SID type ipv6"; | | "Binding SID type ipv6"; |
| } | | } |
| } | | } |
| description | | description |
| "BGP Binding SID type"; | | "BGP Binding SID type"; |
| } | | } |
| | | |
| typedef Bgp-bp-stage { | | typedef Bgp-bp-stage { |
| type enumeration { | | type enumeration { |
| enum "bgp-bp-comp-not-compared" { | | enum "bgp-bp-comp-not-compared" { |
| value 0; | | value 0; |
| description | | description |
| "Best path comparison not performed"; | | "Best path comparison not performed"; |
| } | | } |
| enum "bgp-bp-comp-imulti-path" { | | enum "bgp-bp-comp-imulti-path" { |
| value 1; | | value 1; |
| description | | description |
| "Path is an iBGP multipath"; | | "Path is an iBGP multipath"; |
| } | | } |
| enum "bgp-bp-comp-emulti-path" { | | enum "bgp-bp-comp-emulti-path" { |
| value 2; | | value 2; |
| description | | description |
| "Path is an eBGP multipath"; | | "Path is an eBGP multipath"; |
| } | | } |
| enum "bgp-bp-comp-eimulti-path" { | | enum "bgp-bp-comp-eimulti-path" { |
| value 3; | | value 3; |
| description | | description |
| "Path is an eiBGP multipath"; | | "Path is an eiBGP multipath"; |
| } | | } |
| enum "bgp-bp-invalid-path" { | | enum "bgp-bp-invalid-path" { |
| value 4; | | value 4; |
| description | | description |
| "Invalid path"; | | "Invalid path"; |
| } | | } |
| enum "bgp-bp-comp-pre-cost-comm" { | | enum "bgp-bp-comp-pre-cost-comm" { |
| value 5; | | value 5; |
| description | | description |
| "TODO"; | | "TODO"; |
| } | | } |
| enum "bgp-bp-comp-weight" { | | enum "bgp-bp-comp-weight" { |
| value 6; | | value 6; |
| description | | description |
| "Path has a lower weight"; | | "Path has a lower weight"; |
| } | | } |
| n | enum "bgp-bp-comp-af-specific" { | n | enum "bgp-bp-comp-locpref" { |
| value 7; | | value 7; |
| description | | description |
| n | "Less Favourable Address Family specific | n | "Path has a lower local preference"; |
| attributes"; | | |
| } | | } |
| n | enum "bgp-bp-comp-locpref" { | n | enum "bgp-bp-comp-rpki" { |
| value 8; | | value 8; |
| description | | description |
| n | "Path has a lower local preference"; | n | "Path has worse origin validation state"; |
| } | | } |
| n | enum "bgp-bp-comp-rpki" { | n | enum "bgp-bp-comp-aigp" { |
| value 9; | | value 9; |
| description | | description |
| n | "Path has worse origin validation state"; | n | "TODO"; |
| } | | } |
| n | enum "bgp-bp-comp-aigp" { | n | enum "bgp-bp-comp-local" { |
| value 10; | | value 10; |
| description | | description |
| n | | n | "Path is not local"; |
| | | } |
| | | enum "bgp-bp-comp-local-rib" { |
| | | value 11; |
| | | description |
| "TODO"; | | "TODO"; |
| } | | } |
| n | enum "bgp-bp-comp-local" { | n | enum "bgp-bp-comp-as-path-len" { |
| value 11; | | |
| description | | |
| "Path is not local"; | | |
| } | | |
| enum "bgp-bp-comp-local-rib" { | | |
| value 12; | | value 12; |
| description | | description |
| n | | n | "Path has a longer AS path"; |
| | | } |
| | | enum "bgp-bp-comp-origin" { |
| | | value 13; |
| | | description |
| | | "Path has a less favorable origin"; |
| | | } |
| | | enum "bgp-bp-comp-med" { |
| | | value 14; |
| | | description |
| | | "Path has a lower MED"; |
| | | } |
| | | enum "bgp-bp-comp-ebgp" { |
| | | value 15; |
| | | description |
| | | "Path lost to an eBGP path"; |
| | | } |
| | | enum "bgp-bp-comp-ao" { |
| | | value 16; |
| | | description |
| | | "Path has Accept-Own community"; |
| | | } |
| | | enum "bgp-bp-comp-igp-metric" { |
| | | value 17; |
| | | description |
| | | "Path has a higher IGP metric"; |
| | | } |
| | | enum "bgp-bp-comp-igp-cost-comm" { |
| | | value 18; |
| | | description |
| "TODO"; | | "TODO"; |
| } | | } |
| n | enum "bgp-bp-comp-as-path-len" { | n | |
| value 13; | | |
| description | | |
| "Path has a longer AS path"; | | |
| } | | |
| enum "bgp-bp-comp-origin" { | | |
| value 14; | | |
| description | | |
| "Path has a less favorable origin"; | | |
| } | | |
| enum "bgp-bp-comp-med" { | | enum "bgp-bp-comp-rtr-id" { |
| value 15; | | |
| description | | |
| "Path has a lower MED"; | | |
| } | | |
| enum "bgp-bp-comp-ebgp" { | | |
| value 16; | | |
| description | | |
| "Path lost to an eBGP path"; | | |
| } | | |
| enum "bgp-bp-comp-ao" { | | |
| value 17; | | |
| description | | |
| "Path has Accept-Own community"; | | |
| } | | |
| enum "bgp-bp-comp-xtc-nh-ad" { | | |
| value 18; | | |
| description | | |
| "Path has a higher SR-TE nexthop admin distance"; | | |
| } | | |
| enum "bgp-bp-comp-igp-metric" { | | |
| value 19; | | value 19; |
| description | | description |
| n | "Path has a higher IGP metric"; | n | "Path has a higher router ID"; |
| } | | } |
| n | enum "bgp-bp-comp-igp-cost-comm" { | n | enum "bgp-bp-comp-clstr-len" { |
| value 20; | | value 20; |
| description | | description |
| n | "TODO"; | n | "Path has a longer cluster length"; |
| } | | } |
| n | enum "bgp-bp-comp-rtr-id" { | n | enum "bgp-bp-comp-nbr-addr" { |
| value 21; | | value 21; |
| description | | description |
| n | "Path has a higher router ID"; | n | "Path has a higher neighbor address"; |
| } | | } |
| n | enum "bgp-bp-comp-clstr-len" { | n | enum "bgp-bp-comp-suppressed" { |
| value 22; | | value 22; |
| description | | description |
| n | "Path has a longer cluster length"; | n | "Path is newer than best path"; |
| } | | } |
| n | enum "bgp-bp-comp-nbr-addr" { | n | enum "bgp-bp-comp-mismatch" { |
| value 23; | | value 23; |
| n | description | n | |
| "Path has a higher neighbor address"; | | |
| } | | |
| enum "bgp-bp-comp-suppressed" { | | |
| value 24; | | |
| description | | |
| "Path is newer than best path"; | | |
| } | | |
| enum "bgp-bp-comp-mismatch" { | | |
| value 25; | | |
| description | | description |
| "Best path comparison failed, perhaps due to | | "Best path comparison failed, perhaps due to |
| recent configuration changes"; | | recent configuration changes"; |
| } | | } |
| enum "bgp-bp-comp-persistence" { | | enum "bgp-bp-comp-persistence" { |
| n | value 26; | n | value 24; |
| description | | description |
| "Path is persistent"; | | "Path is persistent"; |
| n | } | n | |
| enum "bgp-bp-comp-gshut" { | | |
| value 27; | | |
| description | | |
| "Path received from a neighbor in graceful | | |
| maintenance"; | | |
| } | | |
| enum "bgp-bp-comp-la-test" { | | |
| value 28; | | |
| description | | |
| "Path is older"; | | |
| } | | |
| enum "bgp-bp-comp-srte-tunnel-down" { | | |
| value 29; | | |
| description | | |
| "Non SR-policy path is ignored due to config | | |
| knob"; | | |
| } | | } |
| } | | } |
| description | | description |
| "Bgp bp stage"; | | "Bgp bp stage"; |
| } | | } |
| | | |
| typedef Bgp-v4-v6-len { | | typedef Bgp-v4-v6-len { |
| type enumeration { | | type enumeration { |
| enum "gwnone" { | | enum "gwnone" { |
| value 0; | | value 0; |
| description | | description |
| "NO address length"; | | "NO address length"; |
| } | | } |
| enum "gwipv4" { | | enum "gwipv4" { |
| value 4; | | value 4; |
| description | | description |
| "IP v4 address length"; | | "IP v4 address length"; |
| } | | } |
| enum "gwipv6" { | | enum "gwipv6" { |
| value 16; | | value 16; |
| description | | description |
| "IP v6 address length"; | | "IP v6 address length"; |
| } | | } |
| } | | } |
| description | | description |
| "BGP GW Address Length"; | | "BGP GW Address Length"; |
| } | | } |
| | | |
| n | typedef Bgp-policy-sl { | n | |
| type enumeration { | | |
| enum "bgp-policy-sl-type-unknown" { | | |
| value 0; | | |
| description | | |
| "SR Policy segment list type UNKOWN"; | | |
| } | | |
| enum "bgp-policy-sl-type-srmpl-sv4" { | | |
| value 1; | | |
| description | | |
| "SR Policy segment list type MPLSv4"; | | |
| } | | |
| enum "bgp-policy-sl-type-srmpl-sv6" { | | |
| value 2; | | |
| description | | |
| "SR Policy segment list type MPLSv6"; | | |
| } | | |
| enum "bgp-policy-sl-type-srv6" { | | |
| value 3; | | |
| description | | |
| "SR Policy segment list type SRV6"; | | |
| } | | |
| } | | |
| description | | |
| "Bgp policy sl"; | | |
| } | | |
| | | |
| typedef Bgp-tunnel { | | typedef Bgp-tunnel { |
| type enumeration { | | type enumeration { |
| enum "tunnel-none" { | | enum "tunnel-none" { |
| value 0; | | value 0; |
| description | | description |
| "Tunnel not applicable"; | | "Tunnel not applicable"; |
| } | | } |
| enum "attrset" { | | enum "attrset" { |
| value 1; | | value 1; |
| description | | description |
| "Attribute set TE tunnel"; | | "Attribute set TE tunnel"; |
| } | | } |
| enum "sr-policy" { | | enum "sr-policy" { |
| value 2; | | value 2; |
| description | | description |
| "SR Policy"; | | "SR Policy"; |
| } | | } |
| enum "odn-policy" { | | enum "odn-policy" { |
| value 4; | | value 4; |
| description | | description |
| "ODN color"; | | "ODN color"; |
| } | | } |
| } | | } |
| description | | description |
| "BGP tunnel type"; | | "BGP tunnel type"; |
| } | | } |
| | | |
| typedef Bgp-route1 { | | typedef Bgp-route1 { |
| type enumeration { | | type enumeration { |
| enum "bgp-route-type-used" { | | enum "bgp-route-type-used" { |
| value 0; | | value 0; |
| description | | description |
| "Used path from neighbor"; | | "Used path from neighbor"; |
| } | | } |
| enum "bgp-route-type-rcvd-only" { | | enum "bgp-route-type-rcvd-only" { |
| value 1; | | value 1; |
| description | | description |
| "Received only path from neighbor"; | | "Received only path from neighbor"; |
| } | | } |
| enum "bgp-route-type-safi-label-ed-ucast-used" { | | enum "bgp-route-type-safi-label-ed-ucast-used" { |
| value 2; | | value 2; |
| description | | description |
| "Used path from neighbor received via | | "Used path from neighbor received via |
| labeled-unicast SAFI"; | | labeled-unicast SAFI"; |
| } | | } |
| enum "bgp-route-type-safi-label-ed-ucast-rcvd-only" { | | enum "bgp-route-type-safi-label-ed-ucast-rcvd-only" { |
| value 3; | | value 3; |
| description | | description |
| "Received only path from neighbor received via | | "Received only path from neighbor received via |
| labeled-unicast SAFI"; | | labeled-unicast SAFI"; |
| } | | } |
| enum "bgp-route-type-rib" { | | enum "bgp-route-type-rib" { |
| value 4; | | value 4; |
| description | | description |
| "Redistributed from the RIB"; | | "Redistributed from the RIB"; |
| } | | } |
| enum "bgp-route-type-aggregate" { | | enum "bgp-route-type-aggregate" { |
| value 5; | | value 5; |
| description | | description |
| "Locally generated aggregate"; | | "Locally generated aggregate"; |
| } | | } |
| enum "bgp-route-type-max" { | | enum "bgp-route-type-max" { |
| value 6; | | value 6; |
| description | | description |
| "Number of route types"; | | "Number of route types"; |
| } | | } |
| } | | } |
| description | | description |
| "Bgp route1"; | | "Bgp route1"; |
| } | | } |
| | | |
| n | typedef Mac-address { | n | |
| type yang:mac-address; | | |
| description | | |
| "MAC Address type"; | | |
| } | | |
| | | |
| typedef Bgp-rpki-af { | | typedef Bgp-rpki-af { |
| type enumeration { | | type enumeration { |
| enum "ipv4" { | | enum "ipv4" { |
| value 2; | | value 2; |
| description | | description |
| "IPv4"; | | "IPv4"; |
| } | | } |
| enum "ipv6" { | | enum "ipv6" { |
| value 26; | | value 26; |
| description | | description |
| "IPv6"; | | "IPv6"; |
| } | | } |
| } | | } |
| description | | description |
| "Bgp rpki af"; | | "Bgp rpki af"; |
| } | | } |
| | | |
| n | typedef Bgp-dryrun-softreconfig-state { | n | |
| type enumeration { | | |
| enum "bgp-dryrun-softre-config-ok" { | | |
| value 0; | | |
| description | | |
| "Soft reconfig is active for the neighbor"; | | |
| } | | |
| enum "bgp-dryrun-softre-config-inactive" { | | |
| value 1; | | |
| description | | |
| "Soft reconfig is not active for the neighbor"; | | |
| } | | |
| } | | |
| description | | |
| "Bgp dryrun softreconfig state"; | | |
| } | | |
| | | |
| typedef Bgp-dryrun-inuse-policy-state { | | |
| type enumeration { | | |
| enum "bgp-dryrun-inuse-permit-policy" { | | |
| value 0; | | |
| description | | |
| "Inuse policy is implicit permit"; | | |
| } | | |
| enum "bgp-dryrun-inuse-deny-policy" { | | |
| value 1; | | |
| description | | |
| "Inuse policy is implicit drop"; | | |
| } | | |
| } | | |
| description | | |
| "Bgp dryrun inuse policy state"; | | |
| } | | |
| | | |
| typedef Bgp-dryrun-policy-error { | | |
| type enumeration { | | |
| enum "bgp-dryrun-policy-ok" { | | |
| value 0; | | |
| description | | |
| "The given dryrun policy is usable"; | | |
| } | | |
| enum "bgp-dryrun-policy-not-exists" { | | |
| value 1; | | |
| description | | |
| "The given dryrun policy is not configured"; | | |
| } | | |
| } | | |
| description | | |
| "Bgp dryrun policy error"; | | |
| } | | |
| | | |
| typedef Bgp-vr-int { | | |
| type enumeration { | | |
| enum "vr-int-live" { | | |
| value 0; | | |
| description | | |
| "5 minute live interval"; | | |
| } | | |
| enum "vr-int-5" { | | |
| value 1; | | |
| description | | |
| "5 minute interval"; | | |
| } | | |
| enum "vr-int-15" { | | |
| value 2; | | |
| description | | |
| "15 minute interval"; | | |
| } | | |
| enum "vr-int-30" { | | |
| value 3; | | |
| description | | |
| "30 minute interval"; | | |
| } | | |
| } | | |
| description | | |
| "Bgp vr int"; | | |
| } | | |
| | | |
| typedef Nbr-vr-bumpcount-event { | | |
| type enumeration { | | |
| enum "nbr-reachable" { | | |
| value 0; | | |
| description | | |
| "Reachable"; | | |
| } | | |
| enum "nbr-unreachable" { | | |
| value 1; | | |
| description | | |
| "Unreachable"; | | |
| } | | |
| } | | |
| description | | |
| "Nbr vr bumpcount event"; | | |
| } | | |
| | | |
| typedef Bgp-sync-nbr-nsr-state { | | |
| type enumeration { | | |
| enum "bgp-nbr-nsr-st-none" { | | |
| description | | |
| "None - ST 0"; | | |
| } | | |
| enum "bgp-nbr-nsr-st-oper-down" { | | |
| description | | |
| "TCP OPER_DOWN notfn received - ST 1"; | | |
| } | | |
| enum "bgp-nbr-nsr-st-tcp-init-sync" { | | |
| description | | |
| "TCP initial sync in progress - ST 2"; | | |
| } | | |
| enum "bgp-nbr-nsr-st-tcp-phase-two" { | | |
| description | | |
| "TCP initial sync phase two in progress - ST 3"; | | |
| } | | |
| enum "bgp-nbr-nsr-st-bgp-init-sync" { | | |
| description | | |
| "BGP initial sync in progress - ST 4"; | | |
| } | | |
| enum "bgp-nbr-nsr-st-nsr-ready" { | | |
| description | | |
| "Neighbor NSR ready - ST 5"; | | |
| } | | |
| } | | |
| description | | |
| "Bgp sync nbr nsr state"; | | |
| } | | |
| | | |
| typedef Bgp-conn-state { | | |
| type enumeration { | | |
| enum "bgp-st-dont-care" { | | |
| value 0; | | |
| description | | |
| "DontCare"; | | |
| } | | |
| enum "bgp-st-idle" { | | |
| value 1; | | |
| description | | |
| "Idle"; | | |
| } | | |
| enum "bgp-st-connect" { | | |
| value 2; | | |
| description | | |
| "Connect"; | | |
| } | | |
| enum "bgp-st-active" { | | |
| value 3; | | |
| description | | |
| "Active"; | | |
| } | | |
| enum "bgp-st-open-sent" { | | |
| value 4; | | |
| description | | |
| "OpenSent"; | | |
| } | | |
| enum "bgp-st-open-confirm" { | | |
| value 5; | | |
| description | | |
| "OpenConfirm"; | | |
| } | | |
| enum "bgp-st-estab" { | | |
| value 6; | | |
| description | | |
| "Established"; | | |
| } | | |
| enum "bgp-st-closing" { | | |
| value 7; | | |
| description | | |
| "Closing"; | | |
| } | | |
| enum "bgp-st-closing-sync" { | | |
| value 8; | | |
| description | | |
| "ClosingSync"; | | |
| } | | |
| } | | |
| description | | |
| "Bgp conn state"; | | |
| } | | |
| | | |
| typedef Bgp-nbr-disable-peer-as { | | |
| type enumeration { | | |
| enum "bgp-disable-peer-as-none" { | | |
| description | | |
| "neighbor disable peer as not configured"; | | |
| } | | |
| enum "bgp-disable-peer-as-false" { | | |
| description | | |
| "neighbor disable peer as enabled"; | | |
| } | | |
| enum "bgp-disable-peer-as-true" { | | |
| description | | |
| "neighbor disable peer as disabled"; | | |
| } | | |
| } | | |
| description | | |
| "Bgp nbr disable peer as"; | | |
| } | | |
| | | |
| typedef Bgp-nbr-aspath-as-override { | | |
| type enumeration { | | |
| enum "bgp-as-path-as-override-none" { | | |
| description | | |
| "neighbor aspath override not configured"; | | |
| } | | |
| enum "bgp-as-path-as-override-enable" { | | |
| description | | |
| "neighbor aspath override enabled"; | | |
| } | | |
| enum "bgp-as-path-as-override-disable" { | | |
| description | | |
| "neighbor aspath override disabled"; | | |
| } | | |
| } | | |
| description | | |
| "Bgp nbr aspath as override"; | | |
| } | | |
| | | |
| typedef Bgp-nbr-dampening { | | |
| type enumeration { | | |
| enum "bgp-nbr-dampening-none" { | | |
| description | | |
| "neighbor dampening not configured"; | | |
| } | | |
| enum "bgp-nbr-dampening-enable" { | | |
| description | | |
| "neighbor dampening enabled"; | | |
| } | | |
| enum "bgp-nbr-dampening-disable" { | | |
| description | | |
| "neighbor dampening disabled"; | | |
| } | | |
| } | | |
| description | | |
| "Bgp nbr dampening"; | | |
| } | | |
| | | |
| typedef Bgp-evpn-link-bw-edm { | | |
| type enumeration { | | |
| enum "invalid" { | | |
| value 0; | | |
| description | | |
| "EVPN Link Bandwidth Invalid type"; | | |
| } | | |
| enum "bandwidth" { | | |
| value 1; | | |
| description | | |
| "EVPN Link Bandwidth Bandwidth in Mbps type"; | | |
| } | | |
| enum "per-path" { | | |
| value 2; | | |
| description | | |
| "EVPN Link Bandwidth Per-Path type"; | | |
| } | | |
| } | | |
| description | | |
| "EVPN Link Bandwidth Generalized Type"; | | |
| } | | |
| | | |
| typedef Bgp-gshut-bw-mode { | | |
| type enumeration { | | |
| enum "bgp-gshut-bw-aware-mode-none" { | | |
| value 0; | | |
| description | | |
| "Bandwidth-Aware Graceful-Maintenance not | | |
| configured"; | | |
| } | | |
| enum "bgp-gshut-bw-aware-mode-bandwidth" { | | |
| value 1; | | |
| description | | |
| "Bandwidth-Aware Graceful-Maintenance in | | |
| bandwidth threshold"; | | |
| } | | |
| enum "bgp-gshut-bw-aware-mode-percentage" { | | |
| value 2; | | |
| description | | |
| "Bandwidth-Aware Graceful-Maintenance in | | |
| percentage threshold"; | | |
| } | | |
| } | | |
| description | | |
| "Bgp gshut bw mode"; | | |
| } | | |
| | | |
| typedef Bgp-tcp-mode { | | typedef Bgp-tcp-mode { |
| type enumeration { | | type enumeration { |
| enum "bgp-tcp-mode-type-either" { | | enum "bgp-tcp-mode-type-either" { |
| value 0; | | value 0; |
| description | | description |
| "Use either active or passive mode"; | | "Use either active or passive mode"; |
| } | | } |
| enum "bgp-tcp-mode-type-active-only" { | | enum "bgp-tcp-mode-type-active-only" { |
| value 1; | | value 1; |
| description | | description |
| "Use active mode only"; | | "Use active mode only"; |
| } | | } |
| enum "bgp-tcp-mode-type-passive-only" { | | enum "bgp-tcp-mode-type-passive-only" { |
| value 2; | | value 2; |
| description | | description |
| "Use passive mode only"; | | "Use passive mode only"; |
| } | | } |
| } | | } |
| description | | description |
| "Bgp tcp mode"; | | "Bgp tcp mode"; |
| } | | } |
| | | |
| typedef Bgp-ebgp-send-dmz-enable-mode { | | typedef Bgp-ebgp-send-dmz-enable-mode { |
| type enumeration { | | type enumeration { |
| enum "bgp-ebgp-send-dmz-disable" { | | enum "bgp-ebgp-send-dmz-disable" { |
| value 0; | | value 0; |
| description | | description |
| "EBGP send extended community dmz link bandwidth | | "EBGP send extended community dmz link bandwidth |
| disabled "; | | disabled "; |
| } | | } |
| enum "bgp-ebgp-send-dmz-dflt" { | | enum "bgp-ebgp-send-dmz-dflt" { |
| value 1; | | value 1; |
| description | | description |
| "EBGP send extended community dmz link bandwidth | | "EBGP send extended community dmz link bandwidth |
| default mode "; | | default mode "; |
| } | | } |
| enum "bgp-ebgp-send-dmz-cumulative" { | | enum "bgp-ebgp-send-dmz-cumulative" { |
| value 2; | | value 2; |
| description | | description |
| "EBGP send extended community dmz link bandwidth | | "EBGP send extended community dmz link bandwidth |
| cumulative mode"; | | cumulative mode"; |
| } | | } |
| } | | } |
| description | | description |
| "EBGP send extended community dmz link bandwidth | | "EBGP send extended community dmz link bandwidth |
| enable mode"; | | enable mode"; |
| } | | } |
| | | |
| typedef Bgp-entities { | | typedef Bgp-entities { |
| type enumeration { | | type enumeration { |
| enum "af-group" { | | enum "af-group" { |
| value 0; | | value 0; |
| description | | description |
| "AF groups"; | | "AF groups"; |
| } | | } |
| enum "session-group" { | | enum "session-group" { |
| value 1; | | value 1; |
| description | | description |
| "Session Groups"; | | "Session Groups"; |
| } | | } |
| enum "neighbor-group" { | | enum "neighbor-group" { |
| value 2; | | value 2; |
| description | | description |
| "Neighbor Groups"; | | "Neighbor Groups"; |
| } | | } |
| enum "neighbor" { | | enum "neighbor" { |
| value 3; | | value 3; |
| description | | description |
| "Neighbors"; | | "Neighbors"; |
| } | | } |
| } | | } |
| description | | description |
| "Entity type"; | | "Entity type"; |
| } | | } |
| | | |
| typedef Ipv6-flowspec-address { | | typedef Ipv6-flowspec-address { |
| type xr:Bgp-ipv6-flowspec-address; | | type xr:Bgp-ipv6-flowspec-address; |
| description | | description |
| "IPv6 Flowspec Address type"; | | "IPv6 Flowspec Address type"; |
| } | | } |
| | | |
| typedef Ipv4-flowspec-address { | | typedef Ipv4-flowspec-address { |
| type xr:Bgp-ipv4-flowspec-address; | | type xr:Bgp-ipv4-flowspec-address; |
| description | | description |
| "IPv4 Flowspec Address type"; | | "IPv4 Flowspec Address type"; |
| } | | } |
| | | |
| typedef Ls-ls-address { | | typedef Ls-ls-address { |
| type xr:Bgp-ls-addr; | | type xr:Bgp-ls-addr; |
| description | | description |
| "LINKSTATE LINKSTATE Address type"; | | "LINKSTATE LINKSTATE Address type"; |
| } | | } |
| | | |
| n | | n | typedef L2vpn-evpn-address { |
| | | type xr:Bgp-l2vpn-evpn-addrs; |
| | | description |
| | | "L2VPN EVPN Address type"; |
| | | } |
| | | |
| typedef Ipv4mvpn-address { | | typedef Ipv4mvpn-address { |
| type xr:Bgp-ipv4-mvpn-addr; | | type xr:Bgp-ipv4-mvpn-addr; |
| description | | description |
| "IPV4 MVPN Address type"; | | "IPV4 MVPN Address type"; |
| } | | } |
| | | |
| typedef Ipv6mvpn-address { | | typedef Ipv6mvpn-address { |
| type xr:Bgp-ipv6-mvpn-addr; | | type xr:Bgp-ipv6-mvpn-addr; |
| description | | description |
| "IPV6 MVPN Address type"; | | "IPV6 MVPN Address type"; |
| } | | } |
| | | |
| typedef Rt-constraint-address { | | typedef Rt-constraint-address { |
| type xr:Bgp-rt-constrt-addr; | | type xr:Bgp-rt-constrt-addr; |
| description | | description |
| "IPV4 RTConstraint Address type"; | | "IPV4 RTConstraint Address type"; |
| } | | } |
| | | |
| typedef Ipv6-address { | | typedef Ipv6-address { |
| type inet:ipv6-address; | | type inet:ipv6-address; |
| description | | description |
| "IPV6 Address type"; | | "IPV6 Address type"; |
| } | | } |
| | | |
| typedef Ipv4-mdt-address { | | typedef Ipv4-mdt-address { |
| type xr:Bgp-ipv4-mdt-addr; | | type xr:Bgp-ipv4-mdt-addr; |
| description | | description |
| "IPV4MDT Address type"; | | "IPV4MDT Address type"; |
| } | | } |
| | | |
| typedef Ipv4-tunnel-address { | | typedef Ipv4-tunnel-address { |
| type xr:Bgp-ipv4-tunnel-addr; | | type xr:Bgp-ipv4-tunnel-addr; |
| description | | description |
| "IPV4Tunnel Address type"; | | "IPV4Tunnel Address type"; |
| } | | } |
| | | |
| typedef Bgp-afi { | | typedef Bgp-afi { |
| type enumeration { | | type enumeration { |
| enum "ipv4" { | | enum "ipv4" { |
| value 0; | | value 0; |
| description | | description |
| "IP v4 unicast"; | | "IP v4 unicast"; |
| } | | } |
| enum "ipv4-multicast" { | | enum "ipv4-multicast" { |
| value 1; | | value 1; |
| description | | description |
| "IP v4 multicast"; | | "IP v4 multicast"; |
| } | | } |
| enum "ipv4-labeled" { | | enum "ipv4-labeled" { |
| value 2; | | value 2; |
| description | | description |
| "IP v4 label"; | | "IP v4 label"; |
| } | | } |
| enum "ipv4-tunnel" { | | enum "ipv4-tunnel" { |
| value 3; | | value 3; |
| description | | description |
| "IP v4 Tunnel"; | | "IP v4 Tunnel"; |
| } | | } |
| enum "vpnv4" { | | enum "vpnv4" { |
| value 4; | | value 4; |
| description | | description |
| "IP v4 virtual private network"; | | "IP v4 virtual private network"; |
| } | | } |
| enum "ipv6" { | | enum "ipv6" { |
| value 5; | | value 5; |
| description | | description |
| "IP v6 unicast"; | | "IP v6 unicast"; |
| } | | } |
| enum "ipv6-multicast" { | | enum "ipv6-multicast" { |
| value 6; | | value 6; |
| description | | description |
| "IP v6 multicast"; | | "IP v6 multicast"; |
| } | | } |
| enum "ipv6-labeled" { | | enum "ipv6-labeled" { |
| value 7; | | value 7; |
| description | | description |
| "IP v6 label"; | | "IP v6 label"; |
| } | | } |
| enum "vpnv6" { | | enum "vpnv6" { |
| value 8; | | value 8; |
| description | | description |
| "IP v6 virtual private network"; | | "IP v6 virtual private network"; |
| } | | } |
| enum "ipv4-mdt" { | | enum "ipv4-mdt" { |
| value 9; | | value 9; |
| description | | description |
| "IP v4 Multicast Distribution Tree"; | | "IP v4 Multicast Distribution Tree"; |
| } | | } |
| enum "l2vpn-vpls" { | | enum "l2vpn-vpls" { |
| value 10; | | value 10; |
| description | | description |
| "L2VPN VPLS"; | | "L2VPN VPLS"; |
| } | | } |
| enum "rt-constraint" { | | enum "rt-constraint" { |
| value 11; | | value 11; |
| description | | description |
| "IP RT-Constraint"; | | "IP RT-Constraint"; |
| } | | } |
| enum "ipv4-mvpn" { | | enum "ipv4-mvpn" { |
| value 12; | | value 12; |
| description | | description |
| "IP v4 mvpn"; | | "IP v4 mvpn"; |
| } | | } |
| enum "ipv6-mvpn" { | | enum "ipv6-mvpn" { |
| value 13; | | value 13; |
| description | | description |
| "IP v6 mvpn"; | | "IP v6 mvpn"; |
| } | | } |
| enum "l2vpn-evpn" { | | enum "l2vpn-evpn" { |
| value 14; | | value 14; |
| description | | description |
| "L2VPN EVPN"; | | "L2VPN EVPN"; |
| } | | } |
| enum "ls-ls" { | | enum "ls-ls" { |
| value 15; | | value 15; |
| description | | description |
| "Link-state Link-state"; | | "Link-state Link-state"; |
| } | | } |
| enum "vpnv4-multicast" { | | enum "vpnv4-multicast" { |
| value 16; | | value 16; |
| description | | description |
| "IP v4 virtual private network for multicast"; | | "IP v4 virtual private network for multicast"; |
| } | | } |
| enum "vpnv6-multicast" { | | enum "vpnv6-multicast" { |
| value 17; | | value 17; |
| description | | description |
| "IP v6 virtual private network for multicast"; | | "IP v6 virtual private network for multicast"; |
| } | | } |
| enum "ipv4-flowspec" { | | enum "ipv4-flowspec" { |
| value 18; | | value 18; |
| description | | description |
| "IP v4 flowspec"; | | "IP v4 flowspec"; |
| } | | } |
| enum "ipv6-flowspec" { | | enum "ipv6-flowspec" { |
| value 19; | | value 19; |
| description | | description |
| "IP v6 flowspec"; | | "IP v6 flowspec"; |
| } | | } |
| enum "vpnv4-flowspec" { | | enum "vpnv4-flowspec" { |
| value 20; | | value 20; |
| description | | description |
| "IP v4 vpn flowspec"; | | "IP v4 vpn flowspec"; |
| } | | } |
| enum "vpnv6-flowspec" { | | enum "vpnv6-flowspec" { |
| value 21; | | value 21; |
| description | | description |
| "IP v6 vpn flowspec"; | | "IP v6 vpn flowspec"; |
| } | | } |
| enum "l2vpn-mspw" { | | enum "l2vpn-mspw" { |
| value 22; | | value 22; |
| description | | description |
| "L2VPN Multi-segment pseudowire"; | | "L2VPN Multi-segment pseudowire"; |
| } | | } |
| enum "ipv4-sr-policy" { | | enum "ipv4-sr-policy" { |
| value 23; | | value 23; |
| description | | description |
| "IP v4 SR Policy"; | | "IP v4 SR Policy"; |
| } | | } |
| enum "ipv6-sr-policy" { | | enum "ipv6-sr-policy" { |
| value 24; | | value 24; |
| description | | description |
| "IP v6 SR Policy"; | | "IP v6 SR Policy"; |
| } | | } |
| enum "no-address-family" { | | enum "no-address-family" { |
| value 25; | | value 25; |
| description | | description |
| "Address-family not applicable"; | | "Address-family not applicable"; |
| } | | } |
| enum "all-address-families" { | | enum "all-address-families" { |
| value 26; | | value 26; |
| description | | description |
| "All address-families"; | | "All address-families"; |
| } | | } |
| } | | } |
| description | | description |
| "BGP Address family"; | | "BGP Address family"; |
| } | | } |
| | | |
| n | grouping BPM-ORR-GROUP-BAG { | n | |
| description | | |
| "BPM ORR Group Information"; | | |
| container orr-root-address { | | |
| description | | |
| "ORR Root Address"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| container orr-sec-root-address { | | |
| description | | |
| "ORR Sec Root Address"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| container orr-ter-root-address { | | |
| description | | |
| "ORR ter Root Address"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| leaf orr-group-name { | | |
| type string; | | |
| description | | |
| "ORR Group Name"; | | |
| } | | |
| leaf is-orr-group-ipv4 { | | |
| type boolean; | | |
| description | | |
| "Is IPv4 ORR Group"; | | |
| } | | |
| leaf is-orr-global-defined { | | |
| type boolean; | | |
| description | | |
| "Is ORR group configured globally"; | | |
| } | | |
| leaf orrafi-ref-count { | | |
| type uint32; | | |
| description | | |
| "Number of used afis"; | | |
| } | | |
| leaf neighbor-count { | | |
| type uint32; | | |
| description | | |
| "Used by Total number of neighbors"; | | |
| } | | |
| leaf flex-algo { | | |
| type uint32; | | |
| description | | |
| "Flex algo value"; | | |
| } | | |
| leaf is-orr-root-address-configured { | | |
| type boolean; | | |
| description | | |
| "ORR Root address configured"; | | |
| } | | |
| leaf is-orr-sec-root-address-configured { | | |
| type boolean; | | |
| description | | |
| "ORR Sec Root address configured"; | | |
| } | | |
| leaf is-orr-ter-root-address-configured { | | |
| type boolean; | | |
| description | | |
| "ORR Ter Root address configured"; | | |
| } | | |
| leaf addpath-route-policy { | | |
| type string; | | |
| description | | |
| "Route Policy for additional paths selection"; | | |
| } | | |
| list neighbor-af-count { | | |
| max-elements "25"; | | |
| description | | |
| "Used by Total number of neighbors per afi"; | | |
| leaf entry { | | |
| type uint32; | | |
| description | | |
| "Used by Total number of neighbors per afi"; | | |
| } | | |
| } | | |
| list used-af { | | |
| min-elements 25; | | |
| max-elements "25"; | | |
| description | | |
| "Is ORR group used by af"; | | |
| leaf entry { | | |
| type boolean; | | |
| description | | |
| "Array entry."; | | |
| } | | |
| } | | |
| } | | |
| | | |
| grouping BGP-AFLIST-TYPE { | | |
| description | | |
| "Address Families information"; | | |
| leaf af-name { | | |
| type string; | | |
| description | | |
| "The name of Address Families"; | | |
| } | | |
| leaf is-enabled { | | |
| type boolean; | | |
| description | | |
| "Flag to indicat if this AF is enabled"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-INSTANCE-INFO { | | grouping BGP-INSTANCE-INFO { |
| description | | description |
| "BGP instance information"; | | "BGP instance information"; |
| leaf instance-identifier { | | leaf instance-identifier { |
| type uint16; | | type uint16; |
| description | | description |
| n | "The identifier of the BGP instance"; | n | "Instance Identifier"; |
| } | | } |
| leaf placed-group-id { | | leaf placed-group-id { |
| type uint16; | | type uint16; |
| description | | description |
| "Placed Group Identifier"; | | "Placed Group Identifier"; |
| } | | } |
| leaf instance-name-str { | | leaf instance-name-str { |
| type string; | | type string; |
| description | | description |
| n | "BGP Instance Name"; | n | "Instance Name"; |
| } | | } |
| leaf as-number { | | leaf as-number { |
| type uint32; | | type uint32; |
| description | | description |
| "AS Number"; | | "AS Number"; |
| } | | } |
| leaf number-of-vrfs { | | leaf number-of-vrfs { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of VRFs"; | | "Number of VRFs"; |
| } | | } |
| leaf read-only-enabled { | | leaf read-only-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if BGP Read-Only mode is | n | "Read-only is enabled"; |
| enabled"; | | |
| } | | } |
| leaf install-diversion-enabled { | | leaf install-diversion-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if BGP Install diversion is | n | "Install diversion is enabled"; |
| enabled"; | | |
| } | | } |
| leaf srgb-start-configured { | | leaf srgb-start-configured { |
| type uint32; | | type uint32; |
| description | | description |
| "Configured start value of Segment-routing global | | "Configured start value of Segment-routing global |
| block"; | | block"; |
| } | | } |
| leaf srgb-end-configured { | | leaf srgb-end-configured { |
| type uint32; | | type uint32; |
| description | | description |
| "Configured end value of Segment-routing global | | "Configured end value of Segment-routing global |
| block"; | | block"; |
| } | | } |
| list af-array { | | list af-array { |
| n | | n | min-elements 25; |
| max-elements "25"; | | max-elements "25"; |
| description | | description |
| n | "List of Address Families"; | n | "Array of Address Families"; |
| uses BGP-AFLIST-TYPE; | | leaf entry { |
| | | type boolean; |
| | | description |
| | | "Array entry."; |
| | | } |
| } | | } |
| } | | } |
| | | |
| grouping BGP-INSTANCES-INFO-BAG { | | grouping BGP-INSTANCES-INFO-BAG { |
| description | | description |
| "BGP instances information bag"; | | "BGP instances information bag"; |
| list instance { | | list instance { |
| description | | description |
| "Array of instance information"; | | "Array of instance information"; |
| uses BGP-INSTANCE-INFO; | | uses BGP-INSTANCE-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-EDM-LABEL-RPF-NBR { | | grouping BGP-EDM-LABEL-RPF-NBR { |
| description | | description |
| "BGP EDM LABEL RPF NBR"; | | "BGP EDM LABEL RPF NBR"; |
| leaf ip { | | leaf ip { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| n | "The ip address of the BGP edm rpf nbr"; | n | "ip"; |
| } | | } |
| leaf ip6 { | | leaf ip6 { |
| type inet:ipv6-address; | | type inet:ipv6-address; |
| description | | description |
| n | "The ipv6 address of the BGP edm rpf nbr"; | n | "ip6"; |
| } | | } |
| leaf count { | | leaf count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "The number of prefixes for rpf"; | n | "count"; |
| } | | } |
| leaf flags { | | leaf flags { |
| type uint32; | | type uint32; |
| description | | description |
| n | "RPF neighbor node flags"; | n | "flags"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-EDM-LABEL-RPF-INFO { | | grouping BGP-EDM-LABEL-RPF-INFO { |
| description | | description |
| "BGP EDM LABEL RPF INFO"; | | "BGP EDM LABEL RPF INFO"; |
| leaf label { | | leaf label { |
| type uint32; | | type uint32; |
| description | | description |
| n | "The label of the BGP rpf"; | n | "label"; |
| } | | } |
| leaf flags { | | leaf flags { |
| type uint32; | | type uint32; |
| description | | description |
| n | "The flags of the BGP rpf"; | n | "flags"; |
| } | | } |
| leaf install { | | leaf install { |
| type Bgp-label-rpf-install; | | type Bgp-label-rpf-install; |
| description | | description |
| n | "The BGP label rpf install"; | n | "install"; |
| } | | } |
| list rpf { | | list rpf { |
| description | | description |
| "rpf"; | | "rpf"; |
| uses BGP-EDM-LABEL-RPF-NBR; | | uses BGP-EDM-LABEL-RPF-NBR; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-LABEL-RPF-BAG { | | grouping BGP-LABEL-RPF-BAG { |
| description | | description |
| "BGP LABEL RPF BAG"; | | "BGP LABEL RPF BAG"; |
| container rpf { | | container rpf { |
| description | | description |
| n | "The reverse path forwarding (RPF) of BGP label"; | n | "rpf"; |
| uses BGP-EDM-LABEL-RPF-INFO; | | uses BGP-EDM-LABEL-RPF-INFO; |
| n | } | n | |
| } | | |
| | | |
| grouping BGP-MEMORY-HWM-BAG { | | |
| description | | |
| "BGP memory high water mark information"; | | |
| leaf memory-used { | | |
| type uint64; | | |
| description | | |
| "Memory used by the BGP process"; | | |
| } | | |
| leaf rlimit-percentage { | | |
| type int32; | | |
| units "percentage"; | | |
| description | | |
| "Memory percentage of rlimit"; | | |
| } | | |
| leaf networks { | | |
| type uint32; | | |
| description | | |
| "Number of networks"; | | |
| } | | |
| leaf paths { | | |
| type uint32; | | |
| description | | |
| "Number of paths"; | | |
| } | | |
| leaf path-elems { | | |
| type uint32; | | |
| description | | |
| "Number of path elems"; | | |
| } | | |
| leaf attribute-count { | | |
| type uint32; | | |
| description | | |
| "Number of attributes"; | | |
| } | | |
| leaf time { | | |
| type uint32; | | |
| description | | |
| "Time that the report was generated"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-EDM-OT-PROV-NBR-AF-DB-ENTRY { | | |
| description | | |
| "BGP EDM OT PROV NBR AF DB ENTRY"; | | |
| container neighbor-address { | | |
| description | | |
| "BGP neighbor Address"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| container track-created-ts { | | |
| description | | |
| "track created ts"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container track-created-age { | | |
| description | | |
| "track created age"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container nbr-af-event-ts { | | |
| description | | |
| "nbr af event ts"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container nbr-af-event-age { | | |
| description | | |
| "nbr af event age"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container status-change-ts { | | |
| description | | |
| "status change ts"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container status-change-age { | | |
| description | | |
| "status change age"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container status-notify-ts { | | |
| description | | |
| "status notify ts"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container status-notify-age { | | |
| description | | |
| "status notify age"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| leaf vrf-name { | | |
| type string; | | |
| description | | |
| "vrf name"; | | |
| } | | |
| leaf afi { | | |
| type uint8; | | |
| description | | |
| "afi"; | | |
| } | | |
| leaf state { | | |
| type Bgp-track-state; | | |
| description | | |
| "BGP Track Entry State"; | | |
| } | | |
| leaf flags { | | |
| type uint8; | | |
| description | | |
| "flags"; | | |
| } | | |
| leaf notify-state { | | |
| type Bgp-track-state; | | |
| description | | |
| "BGP Track Entry Previous State"; | | |
| } | | |
| leaf prev-state { | | |
| type Bgp-track-state; | | |
| description | | |
| "BGP Track Entry Previous State"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-OT-PROV-NBR-AF-DB-BAG { | | |
| description | | |
| "BGP OT PROV NBR AF DB BAG"; | | |
| container entry { | | |
| description | | |
| "entry"; | | |
| uses BGP-EDM-OT-PROV-NBR-AF-DB-ENTRY; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-VRF-RT-HASH-SLICE-BAG { | | |
| description | | |
| "BGP VRF RT HASH SLICE BAG"; | | |
| leaf route-target-hash-value { | | |
| type uint32; | | |
| description | | |
| "Hash value calculated from Route Target value | | |
| used to save in BGP's internal hash table"; | | |
| } | | |
| list rt { | | |
| description | | |
| "rt"; | | |
| uses BGP-EDM-RT-ENTRY; | | |
| } | | } |
| } | | } |
| | | |
| grouping BGP-RPKI-SUMMARY-BAG { | | grouping BGP-RPKI-SUMMARY-BAG { |
| description | | description |
| "BGP RPKI SUMMARY BAG"; | | "BGP RPKI SUMMARY BAG"; |
| leaf servers { | | leaf servers { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of RPKI Servers configured"; | | "Number of RPKI Servers configured"; |
| } | | } |
| leaf ipv4roa-nets { | | leaf ipv4roa-nets { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of IPv4 ROA Nets"; | | "Number of IPv4 ROA Nets"; |
| } | | } |
| leaf ipv4roa-paths { | | leaf ipv4roa-paths { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of IPv4 ROA Paths"; | | "Number of IPv4 ROA Paths"; |
| } | | } |
| leaf ipv6roa-nets { | | leaf ipv6roa-nets { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of IPv6 ROA Nets"; | | "Number of IPv6 ROA Nets"; |
| } | | } |
| leaf ipv6roa-paths { | | leaf ipv6roa-paths { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of IPv6 ROA Paths"; | | "Number of IPv6 ROA Paths"; |
| n | } | n | |
| leaf ipv4-table-version { | | |
| type uint64; | | |
| description | | |
| "RPKI IPv4 Table Version"; | | |
| } | | |
| leaf ipv4-table-scanner-version { | | |
| type uint64; | | |
| description | | |
| "RPKI IPv4 Scanner Version"; | | |
| } | | |
| leaf ipv6-table-version { | | |
| type uint64; | | |
| description | | |
| "RPKI IPv6 Table Version"; | | |
| } | | |
| leaf ipv6-table-scanner-version { | | |
| type uint64; | | |
| description | | |
| "RPKI IPv6 Scanner Version"; | | |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPDERR-PROC-BAG { | | grouping BGP-UPDERR-PROC-BAG { |
| description | | description |
| "BGP Update error-handling Process information"; | | "BGP Update error-handling Process information"; |
| container last-update-malformed-timestamp { | | container last-update-malformed-timestamp { |
| description | | description |
| "Last malformed messages received time: time | | "Last malformed messages received time: time |
| elapsed since 00:00:00 UTC, January 1, 1970"; | | elapsed since 00:00:00 UTC, January 1, 1970"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| leaf update-error-handling-basic-ebgp { | | leaf update-error-handling-basic-ebgp { |
| type boolean; | | type boolean; |
| description | | description |
| "Is basic error-handling for EBGP enabled"; | | "Is basic error-handling for EBGP enabled"; |
| } | | } |
| leaf update-error-handling-basic-ibgp { | | leaf update-error-handling-basic-ibgp { |
| type boolean; | | type boolean; |
| description | | description |
| "Is basic error-handling for IBGP enabled"; | | "Is basic error-handling for IBGP enabled"; |
| } | | } |
| leaf update-error-handling-extended-ebgp { | | leaf update-error-handling-extended-ebgp { |
| type boolean; | | type boolean; |
| description | | description |
| "Is extended error-handling for EBGP enabled"; | | "Is extended error-handling for EBGP enabled"; |
| } | | } |
| leaf update-error-handling-extended-ibgp { | | leaf update-error-handling-extended-ibgp { |
| type boolean; | | type boolean; |
| description | | description |
| "Is extended error-handling for IBGP enabled"; | | "Is extended error-handling for IBGP enabled"; |
| } | | } |
| leaf update-malformed-message-count { | | leaf update-malformed-message-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP malformed messages received count update"; | n | "Malformed messages count"; |
| } | | } |
| leaf update-malformed-neighbor-count { | | leaf update-malformed-neighbor-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Count of neighbors that received malformed | | "Count of neighbors that received malformed |
| messages"; | | messages"; |
| } | | } |
| leaf last-update-malformed-age { | | leaf last-update-malformed-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last malformed messages received | | "Time since last malformed messages received |
| event (in seconds)"; | | event (in seconds)"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-EDM-RPKI-ROUTE { | | grouping BGP-EDM-RPKI-ROUTE { |
| description | | description |
| "BGP EDM RPKI ROUTE"; | | "BGP EDM RPKI ROUTE"; |
| leaf af-name { | | leaf af-name { |
| type Bgp-rpki-af; | | type Bgp-rpki-af; |
| description | | description |
| "Address Family"; | | "Address Family"; |
| } | | } |
| leaf address { | | leaf address { |
| type string; | | type string; |
| description | | description |
| "Address Prefix"; | | "Address Prefix"; |
| } | | } |
| leaf min-prefix-len { | | leaf min-prefix-len { |
| type uint8; | | type uint8; |
| description | | description |
| "Minimum Prefix Length"; | | "Minimum Prefix Length"; |
| } | | } |
| leaf max-prefix-len { | | leaf max-prefix-len { |
| type uint8; | | type uint8; |
| description | | description |
| "Maximum Prefix Length"; | | "Maximum Prefix Length"; |
| } | | } |
| leaf as { | | leaf as { |
| type uint32; | | type uint32; |
| description | | description |
| "AS number"; | | "AS number"; |
| } | | } |
| n | | n | leaf refcount { |
| | | type uint16; |
| | | description |
| | | "Refcount"; |
| | | } |
| leaf server { | | leaf server { |
| type string; | | type string; |
| description | | description |
| "Source Server"; | | "Source Server"; |
| } | | } |
| leaf stale { | | leaf stale { |
| type boolean; | | type boolean; |
| description | | description |
| "ROA is stale"; | | "ROA is stale"; |
| } | | } |
| n | leaf version { | n | |
| type uint64; | | |
| description | | |
| "ROA version"; | | |
| } | | |
| } | | } |
| | | |
| grouping BGP-RPKI-ROUTES-BAG { | | grouping BGP-RPKI-ROUTES-BAG { |
| description | | description |
| "BGP RPKI ROUTES BAG"; | | "BGP RPKI ROUTES BAG"; |
| list rpki-route { | | list rpki-route { |
| description | | description |
| "Array or RPKI routes"; | | "Array or RPKI routes"; |
| uses BGP-EDM-RPKI-ROUTE; | | uses BGP-EDM-RPKI-ROUTE; |
| } | | } |
| } | | } |
| | | |
| n | grouping BGP-EDM-GSHUT-IF-ENTRY { | n | |
| description | | |
| "BGP EDM GSHUT IF ENTRY"; | | |
| container gshut-if-time-stamp { | | |
| description | | |
| "BGP gshut timestamp"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container gshut-if-age { | | |
| description | | |
| "BGP gshut if age"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| leaf name { | | |
| type string; | | |
| description | | |
| "Name"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-GSHUT-IF-BAG { | | |
| description | | |
| "gshut interface information"; | | |
| container if-entry { | | |
| description | | |
| "The entry of gshut interface"; | | |
| uses BGP-EDM-GSHUT-IF-ENTRY; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-EDM-GSHUT-LOC-ENTRY { | | |
| description | | |
| "BGP EDM GSHUT LOC ENTRY"; | | |
| container gshut-loc-time-stap { | | |
| description | | |
| "BGP gshut locationb timestamp"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container gshut-loc-age { | | |
| description | | |
| "BGP gshut location age"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| leaf loc { | | |
| type uint32; | | |
| description | | |
| "BGP gshut location nodeif"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-GSHUT-LOC-BAG { | | |
| description | | |
| "gshut location information"; | | |
| container loc-entry { | | |
| description | | |
| "The entry of gshut location"; | | |
| uses BGP-EDM-GSHUT-LOC-ENTRY; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-EDM-GSHUT-NBR-ALL-ENTRY { | | |
| description | | |
| "BGP EDM GSHUT NBR ALL ENTRY"; | | |
| container gshut-nbr-all-ts { | | |
| description | | |
| "BGP gshut nbr-all timestamp"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container gshut-nbr-all-age { | | |
| description | | |
| "BGP gshut nbr-all age"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| leaf nbr-all { | | |
| type uint32; | | |
| description | | |
| "BGP gshut nbr-all entry"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-GSHUT-NBR-ALL-BAG { | | |
| description | | |
| "gshut nbr all information"; | | |
| container nbr-all-entry { | | |
| description | | |
| "The entry of gshut nbr all"; | | |
| uses BGP-EDM-GSHUT-NBR-ALL-ENTRY; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-EDM-LABEL-STATS { | | grouping BGP-EDM-LABEL-STATS { |
| description | | description |
| "BGP EDM LABEL STATS"; | | "BGP EDM LABEL STATS"; |
| leaf nbgp-label-alloc-type-gbl-ipv4 { | | leaf nbgp-label-alloc-type-gbl-ipv4 { |
| type uint32; | | type uint32; |
| description | | description |
| "nBGP LABEL ALLOC TYPE GBL IPv4"; | | "nBGP LABEL ALLOC TYPE GBL IPv4"; |
| } | | } |
| leaf nbgp-label-alloc-type-gbl-ipv6 { | | leaf nbgp-label-alloc-type-gbl-ipv6 { |
| type uint32; | | type uint32; |
| description | | description |
| "nBGP LABEL ALLOC TYPE GBL IPv6"; | | "nBGP LABEL ALLOC TYPE GBL IPv6"; |
| } | | } |
| leaf nbgp-label-alloc-type-vrf-ipv4 { | | leaf nbgp-label-alloc-type-vrf-ipv4 { |
| type uint32; | | type uint32; |
| description | | description |
| "nBGP LABEL ALLOC TYPE VRF IPv4"; | | "nBGP LABEL ALLOC TYPE VRF IPv4"; |
| } | | } |
| leaf nbgp-label-alloc-type-vrf-ipv6 { | | leaf nbgp-label-alloc-type-vrf-ipv6 { |
| type uint32; | | type uint32; |
| description | | description |
| "nBGP LABEL ALLOC TYPE VRF IPv6"; | | "nBGP LABEL ALLOC TYPE VRF IPv6"; |
| } | | } |
| leaf nbgp-label-alloc-type-ce-ipv4 { | | leaf nbgp-label-alloc-type-ce-ipv4 { |
| type uint32; | | type uint32; |
| description | | description |
| "nBGP LABEL ALLOC TYPE CE IPv4"; | | "nBGP LABEL ALLOC TYPE CE IPv4"; |
| } | | } |
| leaf nbgp-label-alloc-type-ce-ipv6 { | | leaf nbgp-label-alloc-type-ce-ipv6 { |
| type uint32; | | type uint32; |
| description | | description |
| "nBGP LABEL ALLOC TYPE CE IPv6"; | | "nBGP LABEL ALLOC TYPE CE IPv6"; |
| } | | } |
| leaf nbgp-label-alloc-type-tbl-ipv4 { | | leaf nbgp-label-alloc-type-tbl-ipv4 { |
| type uint32; | | type uint32; |
| description | | description |
| "nBGP LABEL ALLOC TYPE TBL IPv4"; | | "nBGP LABEL ALLOC TYPE TBL IPv4"; |
| } | | } |
| leaf nbgp-label-alloc-type-tbl-ipv6 { | | leaf nbgp-label-alloc-type-tbl-ipv6 { |
| type uint32; | | type uint32; |
| description | | description |
| "nBGP LABEL ALLOC TYPE TBL IPv6"; | | "nBGP LABEL ALLOC TYPE TBL IPv6"; |
| } | | } |
| n | leaf nbgp-label-alloc-type-vrf-46 { | n | |
| type uint32; | | |
| description | | |
| "nBGP LABEL ALLOC TYPE VRF 46"; | | |
| } | | |
| leaf nbgp-label-alloc-type-vpn-ipv4 { | | leaf nbgp-label-alloc-type-vpn-ipv4 { |
| type uint32; | | type uint32; |
| description | | description |
| "nBGP LABEL ALLOC TYPE VPN IPv4"; | | "nBGP LABEL ALLOC TYPE VPN IPv4"; |
| } | | } |
| leaf nbgp-label-alloc-type-vpn-ipv6 { | | leaf nbgp-label-alloc-type-vpn-ipv6 { |
| type uint32; | | type uint32; |
| description | | description |
| "nBGP LABEL ALLOC TYPE VPN IPv6"; | | "nBGP LABEL ALLOC TYPE VPN IPv6"; |
| } | | } |
| leaf nbgp-label-alloc-type-asbr-nh { | | leaf nbgp-label-alloc-type-asbr-nh { |
| type uint32; | | type uint32; |
| description | | description |
| "nBGP LABEL ALLOC TYPE ASBR NH"; | | "nBGP LABEL ALLOC TYPE ASBR NH"; |
| } | | } |
| n | leaf nbgp-label-alloc-type-l2vpn-evpn { | n | |
| type uint32; | | |
| description | | |
| "nBGP LABEL ALLOC TYPE L2VPN EVPN"; | | |
| } | | |
| leaf nbgp-labels { | | leaf nbgp-labels { |
| type uint32; | | type uint32; |
| description | | description |
| "nBGP LABELS"; | | "nBGP LABELS"; |
| } | | } |
| leaf bgp-label-rpf-lists { | | leaf bgp-label-rpf-lists { |
| type uint32; | | type uint32; |
| description | | description |
| n | "The rpf lists associated withthe label"; | n | "bgp label rpf lists"; |
| } | | } |
| leaf bgp-label-rpf-nodes { | | leaf bgp-label-rpf-nodes { |
| type uint32; | | type uint32; |
| description | | description |
| n | "The rpf nodes associated withthe label"; | n | "bgp label rpf nodes"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-LABEL-SUMMARY-BAG { | | grouping BGP-LABEL-SUMMARY-BAG { |
| description | | description |
| "BGP LABEL SUMMARY BAG"; | | "BGP LABEL SUMMARY BAG"; |
| container stats { | | container stats { |
| description | | description |
| n | "The statistics of the BGP label summary"; | n | "stats"; |
| uses BGP-EDM-LABEL-STATS; | | uses BGP-EDM-LABEL-STATS; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-EDM-RPKI-CACHE { | | grouping BGP-EDM-RPKI-CACHE { |
| description | | description |
| "BGP EDM RPKI CACHE"; | | "BGP EDM RPKI CACHE"; |
| leaf name { | | leaf name { |
| type string; | | type string; |
| description | | description |
| "Server Name"; | | "Server Name"; |
| } | | } |
| leaf preference { | | leaf preference { |
| type uint32; | | type uint32; |
| description | | description |
| "Server Preference"; | | "Server Preference"; |
| } | | } |
| leaf port { | | leaf port { |
| type uint32; | | type uint32; |
| description | | description |
| "Server TCP Port number"; | | "Server TCP Port number"; |
| } | | } |
| leaf state { | | leaf state { |
| type Bgp-rpki-state; | | type Bgp-rpki-state; |
| description | | description |
| "Server Internal State"; | | "Server Internal State"; |
| } | | } |
| leaf state-time { | | leaf state-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Server Internal State timestamp (unix time)"; | | "Server Internal State timestamp (unix time)"; |
| } | | } |
| leaf shutdown { | | leaf shutdown { |
| type boolean; | | type boolean; |
| description | | description |
| "Server Shutdown"; | | "Server Shutdown"; |
| } | | } |
| leaf retries { | | leaf retries { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of connection retries"; | | "Number of connection retries"; |
| } | | } |
| leaf close-reason { | | leaf close-reason { |
| type Bgp-rpki-creason; | | type Bgp-rpki-creason; |
| description | | description |
| "Server close reason"; | | "Server close reason"; |
| } | | } |
| leaf close-time { | | leaf close-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Server close elapsed time"; | | "Server close elapsed time"; |
| } | | } |
| leaf close-time-real { | | leaf close-time-real { |
| type uint32; | | type uint32; |
| description | | description |
| "Server close real timestamp (unix time)"; | | "Server close real timestamp (unix time)"; |
| } | | } |
| leaf read-bytes { | | leaf read-bytes { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Number of bytes read from the server"; | | "Number of bytes read from the server"; |
| } | | } |
| leaf write-bytes { | | leaf write-bytes { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Number of bytes written to the server"; | | "Number of bytes written to the server"; |
| } | | } |
| leaf transport { | | leaf transport { |
| type uint32; | | type uint32; |
| description | | description |
| "Server transport type"; | | "Server transport type"; |
| } | | } |
| leaf username { | | leaf username { |
| type string; | | type string; |
| description | | description |
| "Server SSH username"; | | "Server SSH username"; |
| } | | } |
| leaf password { | | leaf password { |
| type string; | | type string; |
| description | | description |
| "Server SSH password"; | | "Server SSH password"; |
| } | | } |
| leaf sshpid { | | leaf sshpid { |
| type uint32; | | type uint32; |
| description | | description |
| "Server SSH process ID"; | | "Server SSH process ID"; |
| } | | } |
| leaf proto-state { | | leaf proto-state { |
| type Bgp-rpki-pstate; | | type Bgp-rpki-pstate; |
| description | | description |
| "Server Protocol state"; | | "Server Protocol state"; |
| } | | } |
| leaf proto-state-time { | | leaf proto-state-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Server Protocol state timestamp (unix time)"; | | "Server Protocol state timestamp (unix time)"; |
| } | | } |
| leaf serial { | | leaf serial { |
| type uint32; | | type uint32; |
| description | | description |
| "Server serial number"; | | "Server serial number"; |
| } | | } |
| leaf nonce { | | leaf nonce { |
| type uint32; | | type uint32; |
| description | | description |
| "Server nonce"; | | "Server nonce"; |
| } | | } |
| leaf refresh-time { | | leaf refresh-time { |
| type int32; | | type int32; |
| units "second"; | | units "second"; |
| description | | description |
| "Server refresh time (seconds)"; | | "Server refresh time (seconds)"; |
| } | | } |
| leaf response-time { | | leaf response-time { |
| type int32; | | type int32; |
| units "second"; | | units "second"; |
| description | | description |
| "Server response time (seconds)"; | | "Server response time (seconds)"; |
| } | | } |
| leaf purge-time { | | leaf purge-time { |
| type int32; | | type int32; |
| units "second"; | | units "second"; |
| description | | description |
| "Server purge time (seconds)"; | | "Server purge time (seconds)"; |
| } | | } |
| leaf ipv4roa { | | leaf ipv4roa { |
| type uint32; | | type uint32; |
| description | | description |
| "Total IPv4 ROAs currently recv'd from server"; | | "Total IPv4 ROAs currently recv'd from server"; |
| } | | } |
| leaf ipv4roa-announce { | | leaf ipv4roa-announce { |
| type uint32; | | type uint32; |
| description | | description |
| "Total IPv4 ROAs announced by the server"; | | "Total IPv4 ROAs announced by the server"; |
| } | | } |
| leaf ipv4roa-withdraw { | | leaf ipv4roa-withdraw { |
| type uint32; | | type uint32; |
| description | | description |
| "Total IPv4 ROAs withdrawn by the server"; | | "Total IPv4 ROAs withdrawn by the server"; |
| } | | } |
| leaf ipv6roa { | | leaf ipv6roa { |
| type uint32; | | type uint32; |
| description | | description |
| "Total IPv6 ROAs currently recv'd from server"; | | "Total IPv6 ROAs currently recv'd from server"; |
| } | | } |
| leaf ipv6roa-announce { | | leaf ipv6roa-announce { |
| type uint32; | | type uint32; |
| description | | description |
| "Total IPv6 ROAs announced by the server"; | | "Total IPv6 ROAs announced by the server"; |
| } | | } |
| leaf ipv6roa-withdraw { | | leaf ipv6roa-withdraw { |
| type uint32; | | type uint32; |
| description | | description |
| "Total IPv6 ROAs withdrawn by the server"; | | "Total IPv6 ROAs withdrawn by the server"; |
| } | | } |
| leaf proto-error { | | leaf proto-error { |
| type Bgp-rpki-perror; | | type Bgp-rpki-perror; |
| description | | description |
| "Protocol Error Reason"; | | "Protocol Error Reason"; |
| } | | } |
| n | leaf bindsrc { | n | |
| type string; | | |
| description | | |
| "Server transport bind source "; | | |
| } | | |
| leaf identifier { | | |
| type uint8; | | |
| description | | |
| "Allocated Id"; | | |
| } | | |
| } | | } |
| | | |
| grouping BGP-RPKI-CACHES-BAG { | | grouping BGP-RPKI-CACHES-BAG { |
| description | | description |
| "BGP RPKI CACHES BAG"; | | "BGP RPKI CACHES BAG"; |
| list rpki-server { | | list rpki-server { |
| description | | description |
| "Array of RPKI servers"; | | "Array of RPKI servers"; |
| uses BGP-EDM-RPKI-CACHE; | | uses BGP-EDM-RPKI-CACHE; |
| n | } | n | |
| } | | |
| | | |
| grouping BGP-ORR-GROUP-BASE-BAG { | | |
| description | | |
| "BGP GBL ORR Group Information"; | | |
| container orr-root-address { | | |
| description | | |
| "ORR Root Address"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| container orr-sec-root-address { | | |
| description | | |
| "ORR Sec Root Address"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| container orr-ter-root-address { | | |
| description | | |
| "ORR ter Root Address"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| leaf orr-group-name { | | |
| type string; | | |
| description | | |
| "ORR Group Name"; | | |
| } | | |
| leaf is-orr-group-ipv4 { | | |
| type boolean; | | |
| description | | |
| "Is v4 ORR group"; | | |
| } | | |
| leaf is-orr-global-defined { | | |
| type boolean; | | |
| description | | |
| "Is ORR group configured globally"; | | |
| } | | |
| leaf orrafi-ref-count { | | |
| type uint32; | | |
| description | | |
| "Number of used afis"; | | |
| } | | |
| leaf orr-tableid { | | |
| type uint32; | | |
| description | | |
| "ORR Group tableid"; | | |
| } | | |
| leaf flex-algo { | | |
| type uint32; | | |
| description | | |
| "Flex algo value"; | | |
| } | | |
| leaf is-orr-root-address-configured { | | |
| type boolean; | | |
| description | | |
| "ORR Root address configured"; | | |
| } | | |
| leaf is-orr-sec-root-address-configured { | | |
| type boolean; | | |
| description | | |
| "ORR Sec Root address configured"; | | |
| } | | |
| leaf is-orr-ter-root-address-configured { | | |
| type boolean; | | |
| description | | |
| "ORR Ter Root address configured"; | | |
| } | | |
| leaf addpath-route-policy { | | |
| type string; | | |
| description | | |
| "Route Policy for additional paths selection"; | | |
| } | | |
| list used-af { | | |
| min-elements 25; | | |
| max-elements "25"; | | |
| description | | |
| "Is ORR group used by af"; | | |
| leaf entry { | | |
| type boolean; | | |
| description | | |
| "Array entry."; | | |
| } | | |
| } | | |
| } | | |
| | | |
| grouping BGP-MEMORY-HISTORY-BAG { | | |
| description | | |
| "BGP memory history information"; | | |
| leaf memory-used { | | |
| type uint64; | | |
| description | | |
| "Memory used by the BGP process"; | | |
| } | | |
| leaf memory-diff { | | |
| type uint64; | | |
| description | | |
| "Memory difference since last report"; | | |
| } | | |
| leaf rlimit-percentage { | | |
| type int32; | | |
| units "percentage"; | | |
| description | | |
| "Memory percentage of rlimit"; | | |
| } | | |
| leaf networks { | | |
| type uint32; | | |
| description | | |
| "Number of networks"; | | |
| } | | |
| leaf paths { | | |
| type uint32; | | |
| description | | |
| "Number of paths"; | | |
| } | | |
| leaf path-elems { | | |
| type uint32; | | |
| description | | |
| "Number of path elems"; | | |
| } | | |
| leaf attribute-count { | | |
| type uint32; | | |
| description | | |
| "Number of attributes"; | | |
| } | | |
| leaf time { | | |
| type uint32; | | |
| description | | |
| "Time that the report was generated"; | | |
| } | | } |
| } | | } |
| | | |
| grouping BGP-ATTRFILTER-ENTRY-BAG { | | grouping BGP-ATTRFILTER-ENTRY-BAG { |
| description | | description |
| "BGP attribute-filter entry information"; | | "BGP attribute-filter entry information"; |
| leaf attribute-filter-entry-requested-action { | | leaf attribute-filter-entry-requested-action { |
| type Bgp-bag-upd-filter-action; | | type Bgp-bag-upd-filter-action; |
| description | | description |
| "Requested filtering action"; | | "Requested filtering action"; |
| } | | } |
| leaf attribute-filter-entry-range-start { | | leaf attribute-filter-entry-range-start { |
| type uint32; | | type uint32; |
| description | | description |
| "Start of attribute range"; | | "Start of attribute range"; |
| } | | } |
| leaf attribute-filter-entry-range-end { | | leaf attribute-filter-entry-range-end { |
| type uint32; | | type uint32; |
| description | | description |
| "End of attribute range"; | | "End of attribute range"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-ATTRFILTER-GROUP-BAG { | | grouping BGP-ATTRFILTER-GROUP-BAG { |
| description | | description |
| "BGP attribute-filter group information"; | | "BGP attribute-filter group information"; |
| leaf attribute-filter-group-name { | | leaf attribute-filter-group-name { |
| type string; | | type string; |
| description | | description |
| n | "String for BGP attribute-filter group name"; | n | "Attribute-filter group name"; |
| } | | } |
| leaf attribute-filter-total-group-count { | | leaf attribute-filter-total-group-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of attriute-filter groups"; | | "Total number of attriute-filter groups"; |
| } | | } |
| list attribute-filter-entry { | | list attribute-filter-entry { |
| description | | description |
| "List of attriute-filter entries"; | | "List of attriute-filter entries"; |
| uses BGP-ATTRFILTER-ENTRY-BAG; | | uses BGP-ATTRFILTER-ENTRY-BAG; |
| } | | } |
| } | | } |
| | | |
| n | grouping BGP-EVPN-GW-TRACK-BAG { | n | |
| description | | |
| "evpn gateway track information"; | | |
| leaf bvi-interface-handle { | | |
| type xr:Interface-name; | | |
| description | | |
| "BVI Interface handle"; | | |
| } | | |
| leaf bridge-name { | | |
| type string; | | |
| description | | |
| "Name of the Bridge"; | | |
| } | | |
| leaf vrf-name { | | |
| type string; | | |
| description | | |
| "Name of the L3 Vrf"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-EDM-LABEL-ENTRY { | | grouping BGP-EDM-LABEL-ENTRY { |
| description | | description |
| "BGP EDM LABEL ENTRY"; | | "BGP EDM LABEL ENTRY"; |
| leaf label { | | leaf label { |
| type uint32; | | type uint32; |
| description | | description |
| n | "The label of the BGP edm entry"; | n | "label"; |
| } | | } |
| leaf rds { | | leaf rds { |
| type string; | | type string; |
| description | | description |
| n | "The BGP edm route-distinguishers"; | n | "rds"; |
| } | | } |
| leaf vrf { | | leaf vrf { |
| type string; | | type string; |
| description | | description |
| n | "The BGP external data manager labelvirtual | n | "vrf"; |
| routing and forwarding"; | | |
| } | | } |
| leaf ip { | | leaf ip { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| n | "The ip address of the BGP edm label"; | n | "ip"; |
| } | | } |
| leaf ip6 { | | leaf ip6 { |
| type inet:ipv6-address; | | type inet:ipv6-address; |
| description | | description |
| n | "The ipv6 address of the BGP edm label"; | n | "ip6"; |
| } | | } |
| leaf rpc-set-id { | | leaf rpc-set-id { |
| type uint32; | | type uint32; |
| description | | description |
| n | "The id of the rpc set"; | n | "rpc set id"; |
| } | | } |
| leaf masklen { | | leaf masklen { |
| type uint16; | | type uint16; |
| description | | description |
| n | "The length of the mask"; | n | "masklen"; |
| } | | } |
| leaf ts-sec { | | leaf ts-sec { |
| type uint32; | | type uint32; |
| n | units "second"; | n | |
| description | | description |
| n | "The timestamp of the label allocationin seconds"; | n | "ts sec"; |
| } | | } |
| leaf ts-ssec { | | leaf ts-ssec { |
| type uint32; | | type uint32; |
| n | units "second"; | n | |
| description | | description |
| n | "The timestamp of the label allocationin | n | "ts ssec"; |
| subseconds"; | | |
| } | | } |
| leaf info { | | leaf info { |
| type uint16; | | type uint16; |
| description | | description |
| n | "The BGP edm label entry information"; | n | "info"; |
| } | | } |
| leaf refcount { | | leaf refcount { |
| type uint32; | | type uint32; |
| description | | description |
| n | "The number of references updated"; | n | "refcount"; |
| } | | } |
| leaf inactive { | | leaf inactive { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate BGP edm label entryis inactive"; | n | "inactive"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-LABEL-BAG { | | grouping BGP-LABEL-BAG { |
| description | | description |
| "BGP LABEL BAG"; | | "BGP LABEL BAG"; |
| container entry { | | container entry { |
| description | | description |
| n | "The entry for the BGP label"; | n | "entry"; |
| uses BGP-EDM-LABEL-ENTRY; | | uses BGP-EDM-LABEL-ENTRY; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-EDM-RT-ENTRY { | | grouping BGP-EDM-RT-ENTRY { |
| description | | description |
| "BGP EDM RT ENTRY"; | | "BGP EDM RT ENTRY"; |
| leaf route-target { | | leaf route-target { |
| type string; | | type string; |
| description | | description |
| n | "VRF Route Target value"; | n | "route target"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-VRF-RT-BAG { | | grouping BGP-VRF-RT-BAG { |
| description | | description |
| "BGP VRF RT BAG"; | | "BGP VRF RT BAG"; |
| container rt { | | container rt { |
| description | | description |
| n | "BGP virtual routing andforwarding route target"; | n | "rt"; |
| uses BGP-EDM-RT-ENTRY; | | uses BGP-EDM-RT-ENTRY; |
| } | | } |
| leaf afs { | | leaf afs { |
| type string; | | type string; |
| description | | description |
| n | "Address-families of BGPvrf route target"; | n | |
| } | | |
| } | | |
| | | |
| grouping BGP-EDM-VRF-DB-VRF-TBL-ENTRY { | | |
| description | | |
| "BGP EDM VRF DB VRF TBL ENTRY"; | | |
| leaf name { | | |
| type string; | | |
| description | | |
| "name"; | | |
| } | | |
| leaf af { | | |
| type int32; | | |
| description | | |
| "af"; | | "afs"; |
| } | | |
| leaf id { | | |
| type uint32; | | |
| description | | |
| "id"; | | |
| } | | |
| leaf index { | | |
| type uint8; | | |
| description | | |
| "index"; | | |
| } | | |
| leaf rsi-handle { | | |
| type uint64; | | |
| description | | |
| "rsi handle"; | | |
| } | | |
| leaf reg-pending { | | |
| type boolean; | | |
| description | | |
| "reg pending"; | | |
| } | | |
| leaf refcount { | | |
| type uint32; | | |
| description | | |
| "refcount"; | | |
| } | | |
| leaf import-policy { | | |
| type string; | | |
| description | | |
| "import policy"; | | |
| } | | |
| leaf export-policy { | | |
| type string; | | |
| description | | |
| "export policy"; | | |
| } | | |
| leaf l3-vrf-name { | | |
| type string; | | |
| description | | |
| "l3 vrf name"; | | |
| } | | |
| leaf bvi-ifh { | | |
| type xr:Interface-name; | | |
| description | | |
| "bvi ifh"; | | |
| } | | |
| leaf host-tracked { | | |
| type boolean; | | |
| description | | |
| "host tracked"; | | |
| } | | |
| list import-rt { | | |
| description | | |
| "import rt"; | | |
| leaf entry { | | |
| type uint64; | | |
| description | | |
| "import rt"; | | |
| } | | |
| } | | |
| list export-rt { | | |
| description | | |
| "export rt"; | | |
| leaf entry { | | |
| type uint64; | | |
| description | | |
| "export rt"; | | |
| } | | |
| } | | |
| list import-rt-s { | | |
| description | | |
| "import rt s"; | | |
| leaf entry { | | |
| type uint64; | | |
| description | | |
| "import rt s"; | | |
| } | | |
| } | | |
| list export-rt-s { | | |
| description | | |
| "export rt s"; | | |
| leaf entry { | | |
| type uint64; | | |
| description | | |
| "export rt s"; | | |
| } | | |
| } | | |
| } | | |
| | | |
| grouping BGP-VRF-DB-VRF-TBL-BAG { | | |
| description | | |
| "BGP VRF DB VRF TBL BAG"; | | |
| container entry { | | |
| description | | |
| "entry"; | | |
| uses BGP-EDM-VRF-DB-VRF-TBL-ENTRY; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-SRV6-SID-MANAGER-BAG { | | |
| description | | |
| "SRv6 SID Manager information"; | | |
| container first-sid-mgr-connection-up-time-stamp { | | |
| description | | |
| "First SID Manager Connection Up time"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container last-sid-mgr-connection-up-time-stamp { | | |
| description | | |
| "Last SID Manager Connection Up time"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container first-sid-mgr-connection-down-time-stamp { | | |
| description | | |
| "First SID Manager Connection Down time"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container last-sid-mgr-connection-down-time-stamp { | | |
| description | | |
| "Last SID Manager Connection Down time"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| leaf sid-mgr-connection-up-count { | | |
| type uint32; | | |
| description | | |
| "Numer of SID Manager Up events"; | | |
| } | | |
| leaf last-sid-mgr-connection-up-age { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time since last SID Manager Connection Up event | | |
| in seconds"; | | |
| } | | |
| leaf sid-mgr-connection-down-count { | | |
| type uint32; | | |
| description | | |
| "Numer of SID Manager Down events"; | | |
| } | | |
| leaf last-sid-mgr-connection-down-age { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time since last SID Manager Connection Down | | |
| event in seconds"; | | |
| } | | |
| leaf sid-mgr-alive { | | |
| type boolean; | | |
| description | | |
| "SID Manager connection is Up"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-EDM-LOCATOR-ENTRY { | | |
| description | | |
| "BGP EDM LOCATOR ENTRY"; | | |
| leaf locator-name { | | |
| type string; | | |
| description | | |
| "The name of the BGP edmlocator"; | | |
| } | | |
| leaf locator-id { | | |
| type uint32; | | |
| description | | |
| "Locator Id"; | | |
| } | | |
| leaf locator-address { | | |
| type Ipv6-address; | | |
| description | | |
| "The address of the BGP locator"; | | |
| } | | |
| leaf locator-address-len { | | |
| type uint8; | | |
| description | | |
| "The length of the BGP locatoraddress"; | | |
| } | | |
| leaf operation { | | |
| type uint32; | | |
| description | | |
| "Locator operation"; | | |
| } | | |
| leaf oor-state { | | |
| type boolean; | | |
| description | | |
| "Locator OOR"; | | |
| } | | |
| leaf locator-format { | | |
| type uint32; | | |
| description | | |
| "Locator Format"; | | |
| } | | |
| leaf is-locator-active { | | |
| type boolean; | | |
| description | | |
| "Locator State"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-SRV6-LOCATOR-BAG { | | |
| description | | |
| "SRv6 Locator information"; | | |
| container entry { | | |
| description | | |
| "The entry of the BGP srv6 locator"; | | |
| uses BGP-EDM-LOCATOR-ENTRY; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-SRV6-SUMMARY-BAG { | | |
| description | | |
| "SRv6 summary information"; | | |
| leaf locator-count { | | |
| type uint32; | | |
| description | | |
| "Number of locators in bgp"; | | |
| } | | |
| leaf srv6-enabled { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate SRv6 is enabled"; | | |
| } | | |
| leaf stale { | | |
| type boolean; | | |
| description | | |
| "stale"; | | |
| } | | |
| leaf update-count { | | |
| type uint32; | | |
| description | | |
| "number of SIDMGR updates"; | | |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPDFILTER-PROC-BAG { | | grouping BGP-UPDFILTER-PROC-BAG { |
| description | | description |
| "BGP Update filtering Process information"; | | "BGP Update filtering Process information"; |
| container last-update-filtered-timestamp { | | container last-update-filtered-timestamp { |
| description | | description |
| "Last filtered messages received time: time | | "Last filtered messages received time: time |
| elapsed since 00:00:00 UTC, January 1, 1970"; | | elapsed since 00:00:00 UTC, January 1, 1970"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| leaf update-filtered-message-count { | | leaf update-filtered-message-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "The number of messages filtered"; | n | "Filtered messages count"; |
| } | | } |
| leaf update-filtered-neighbor-count { | | leaf update-filtered-neighbor-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Count of neighbors that received filtered | | "Count of neighbors that received filtered |
| messages"; | | messages"; |
| } | | } |
| leaf last-update-filtered-age { | | leaf last-update-filtered-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last filtered messages received event | | "Time since last filtered messages received event |
| (in seconds)"; | | (in seconds)"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-NBR-MSG { | | grouping BGP-NBR-MSG { |
| description | | description |
| "Neighbor In/Out Message entry"; | | "Neighbor In/Out Message entry"; |
| container message-timestamp { | | container message-timestamp { |
| description | | description |
| "message received time: time elapsed since 00:00 | | "message received time: time elapsed since 00:00 |
| :00 UTC, January 1, 1970"; | | :00 UTC, January 1, 1970"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| leaf message-type-received { | | leaf message-type-received { |
| type uint8; | | type uint8; |
| description | | description |
| "Type of messages Received"; | | "Type of messages Received"; |
| } | | } |
| leaf total-logged-message-count { | | leaf total-logged-message-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of total logged messages"; | n | "Total logged messages count"; |
| } | | } |
| leaf message-data-length { | | leaf message-data-length { |
| type uint16; | | type uint16; |
| description | | description |
| n | "Length of the BGP message"; | n | "Message data length"; |
| } | | } |
| list logged-message-data { | | list logged-message-data { |
| description | | description |
| "Raw Message data in binary format"; | | "Raw Message data in binary format"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "Raw Message data in binary format"; | | "Raw Message data in binary format"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping BGP-MSGLOG-NBR-BAG { | | grouping BGP-MSGLOG-NBR-BAG { |
| description | | description |
| "BGP Message logging Neighbor information"; | | "BGP Message logging Neighbor information"; |
| list neighbor-message { | | list neighbor-message { |
| description | | description |
| "Array of Neighbor Messages in one direction"; | | "Array of Neighbor Messages in one direction"; |
| uses BGP-NBR-MSG; | | uses BGP-NBR-MSG; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-NBR-INSTANCE { | | grouping BGP-NBR-INSTANCE { |
| description | | description |
| "Dynamic Neighbor Instance"; | | "Dynamic Neighbor Instance"; |
| container neighbor-address { | | container neighbor-address { |
| description | | description |
| "Dynamic Neighbor address"; | | "Dynamic Neighbor address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container neighbor-age { | | container neighbor-age { |
| description | | description |
| n | "Age of the BGP neighbor"; | n | "Neighbor age"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container idle-watch-timer-remaining-value { | | container idle-watch-timer-remaining-value { |
| description | | description |
| n | "Remaining time in idle watch timer"; | n | "Idle watch timer remaining time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| leaf is-idle-watch-timer-running { | | leaf is-idle-watch-timer-running { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if idle watch timer is running"; | n | "Is idle watch timer running"; |
| } | | } |
| leaf connection-state { | | leaf connection-state { |
| type Bgp-conn-state; | | type Bgp-conn-state; |
| description | | description |
| "State of connection"; | | "State of connection"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-NBR-RANGE-AF { | | grouping BGP-NBR-RANGE-AF { |
| description | | description |
| "BGP neighbor address family specific information"; | | "BGP neighbor address family specific information"; |
| leaf af-name { | | leaf af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Address family identifier"; | | "Address family identifier"; |
| } | | } |
| leaf is-neighbor-route-reflector-client { | | leaf is-neighbor-route-reflector-client { |
| type boolean; | | type boolean; |
| description | | description |
| "Nbr is a route reflector client"; | | "Nbr is a route reflector client"; |
| } | | } |
| leaf is-legacy-pe-rt { | | leaf is-legacy-pe-rt { |
| type boolean; | | type boolean; |
| description | | description |
| "Nbr accepts route from legacy PE for | | "Nbr accepts route from legacy PE for |
| RT-Constraint AF "; | | RT-Constraint AF "; |
| } | | } |
| leaf is-neighbor-af-capable { | | leaf is-neighbor-af-capable { |
| type boolean; | | type boolean; |
| description | | description |
| "Address family capability received from neighbor"; | | "Address family capability received from neighbor"; |
| } | | } |
| leaf is-soft-reconfiguration-inbound-allowed { | | leaf is-soft-reconfiguration-inbound-allowed { |
| type boolean; | | type boolean; |
| description | | description |
| "Inbound soft reconfiguration allowed"; | | "Inbound soft reconfiguration allowed"; |
| } | | } |
| leaf is-use-soft-reconfiguration-always-on { | | leaf is-use-soft-reconfiguration-always-on { |
| type boolean; | | type boolean; |
| description | | description |
| "Soft reconf overrides route refresh"; | | "Soft reconf overrides route refresh"; |
| } | | } |
| leaf remove-private-as-from-updates { | | leaf remove-private-as-from-updates { |
| type boolean; | | type boolean; |
| description | | description |
| "Private AS numbers removed from updates to this | | "Private AS numbers removed from updates to this |
| nbr"; | | nbr"; |
| } | | } |
| leaf remove-private-as-entire-aspath-from-updates { | | leaf remove-private-as-entire-aspath-from-updates { |
| type boolean; | | type boolean; |
| description | | description |
| "Private AS numbers removed from updates to | | "Private AS numbers removed from updates to |
| thisnbr only if the aspath hasonly private ASes"; | | thisnbr only if the aspath hasonly private ASes"; |
| } | | } |
| leaf remove-private-as-from-inbound-updates { | | leaf remove-private-as-from-inbound-updates { |
| type boolean; | | type boolean; |
| description | | description |
| "Private AS numbers removed from updates from | | "Private AS numbers removed from updates from |
| this nbr"; | | this nbr"; |
| } | | } |
| leaf remove-private-as-entire-aspath-from-inbound-updates { | | leaf remove-private-as-entire-aspath-from-inbound-updates { |
| type boolean; | | type boolean; |
| description | | description |
| "Private AS numbers removed from updates from | | "Private AS numbers removed from updates from |
| this nbr only if the aspath has only private | | this nbr only if the aspath has only private |
| ASes"; | | ASes"; |
| } | | } |
| leaf flowspec-validation-d-isable { | | leaf flowspec-validation-d-isable { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if flowspec validation is | n | "Flowspec Validation Disabled"; |
| disabled"; | | |
| } | | } |
| leaf flowspec-redirect-validation-d-isable { | | leaf flowspec-redirect-validation-d-isable { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if flowspec redirect validation | n | "Flowspec Redirect Validation Disabled"; |
| is disabled"; | | |
| } | | } |
| leaf orr-group-name { | | leaf orr-group-name { |
| type string; | | type string; |
| description | | description |
| "ORR Group Name"; | | "ORR Group Name"; |
| } | | } |
| leaf orr-group-index { | | leaf orr-group-index { |
| type uint32; | | type uint32; |
| description | | description |
| "ORR Group Index"; | | "ORR Group Index"; |
| } | | } |
| leaf is-orr-root-address-configured { | | leaf is-orr-root-address-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "ORR Root address configuredfor the neighbor | | "ORR Root address configuredfor the neighbor |
| connection"; | | connection"; |
| } | | } |
| leaf advertise-afi { | | leaf advertise-afi { |
| type boolean; | | type boolean; |
| description | | description |
| "Encode in Advertise AFI"; | | "Encode in Advertise AFI"; |
| } | | } |
| leaf advertise-afi-reorg { | | leaf advertise-afi-reorg { |
| type boolean; | | type boolean; |
| description | | description |
| "Encode in Advertise AFI"; | | "Encode in Advertise AFI"; |
| } | | } |
| leaf advertise-afi-local { | | leaf advertise-afi-local { |
| type boolean; | | type boolean; |
| description | | description |
| "Encode in Advertise AFI"; | | "Encode in Advertise AFI"; |
| } | | } |
| leaf advertise-afi-disable { | | leaf advertise-afi-disable { |
| type boolean; | | type boolean; |
| description | | description |
| "Encode in Advertise AFI"; | | "Encode in Advertise AFI"; |
| } | | } |
| leaf always-use-next-hop-local { | | leaf always-use-next-hop-local { |
| type boolean; | | type boolean; |
| description | | description |
| "Local router always used for next-hop"; | | "Local router always used for next-hop"; |
| } | | } |
| leaf next-hop-unchanged { | | leaf next-hop-unchanged { |
| type boolean; | | type boolean; |
| description | | description |
| "router does not change next-hop"; | | "router does not change next-hop"; |
| } | | } |
| leaf sent-community-to-neighbor { | | leaf sent-community-to-neighbor { |
| type boolean; | | type boolean; |
| description | | description |
| "Community attribute sent to neighbor"; | | "Community attribute sent to neighbor"; |
| } | | } |
| leaf sent-gshut-community-to-neighbor { | | leaf sent-gshut-community-to-neighbor { |
| type boolean; | | type boolean; |
| description | | description |
| "GSHUT Community attribute sent to neighbor"; | | "GSHUT Community attribute sent to neighbor"; |
| } | | } |
| leaf sent-extended-community-to-neighbor { | | leaf sent-extended-community-to-neighbor { |
| type boolean; | | type boolean; |
| description | | description |
| "Extended community attribute sent to neighbor"; | | "Extended community attribute sent to neighbor"; |
| } | | } |
| leaf neighbor-default-originate { | | leaf neighbor-default-originate { |
| type boolean; | | type boolean; |
| description | | description |
| "Neighbor originates default"; | | "Neighbor originates default"; |
| } | | } |
| leaf is-orf-sent { | | leaf is-orf-sent { |
| type boolean; | | type boolean; |
| description | | description |
| "Outbound route filter sent to neighbor"; | | "Outbound route filter sent to neighbor"; |
| } | | } |
| leaf is-update-deferred { | | leaf is-update-deferred { |
| type boolean; | | type boolean; |
| description | | description |
| "Update deferred until ORF/route refresh received"; | | "Update deferred until ORF/route refresh received"; |
| } | | } |
| leaf is-orf-send-scheduled { | | leaf is-orf-send-scheduled { |
| type boolean; | | type boolean; |
| description | | description |
| "Scheduled to send prefix based ORF"; | | "Scheduled to send prefix based ORF"; |
| } | | } |
| leaf vpn-update-gen-enabled { | | leaf vpn-update-gen-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "RT Nbr enabled for updategento another"; | | "RT Nbr enabled for updategento another"; |
| } | | } |
| leaf vpn-update-gen-trigger-enabled { | | leaf vpn-update-gen-trigger-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "RT Nbr enabled for updategento another"; | | "RT Nbr enabled for updategento another"; |
| } | | } |
| leaf is-addpath-send-operational { | | leaf is-addpath-send-operational { |
| type boolean; | | type boolean; |
| description | | description |
| "Addpath is operational on send-side"; | | "Addpath is operational on send-side"; |
| } | | } |
| leaf is-addpath-receive-operational { | | leaf is-addpath-receive-operational { |
| type boolean; | | type boolean; |
| description | | description |
| "Addpath is operational on receive-side"; | | "Addpath is operational on receive-side"; |
| } | | } |
| leaf weight { | | leaf weight { |
| type uint32; | | type uint32; |
| description | | description |
| "Weight for this AF"; | | "Weight for this AF"; |
| } | | } |
| leaf max-prefix-limit { | | leaf max-prefix-limit { |
| type uint32; | | type uint32; |
| description | | description |
| "Max limit for # of prefixes"; | | "Max limit for # of prefixes"; |
| } | | } |
| leaf use-max-prefix-warning-only { | | leaf use-max-prefix-warning-only { |
| type boolean; | | type boolean; |
| description | | description |
| "Warning only when maximum prefix limit reached"; | | "Warning only when maximum prefix limit reached"; |
| } | | } |
| leaf max-prefix-discard-extra-paths { | | leaf max-prefix-discard-extra-paths { |
| type boolean; | | type boolean; |
| description | | description |
| "Discard extra paths when prefix limit reached"; | | "Discard extra paths when prefix limit reached"; |
| } | | } |
| leaf max-prefix-exceed-discard-paths { | | leaf max-prefix-exceed-discard-paths { |
| type boolean; | | type boolean; |
| description | | description |
| "Did we discard extra paths when prefix limit | | "Did we discard extra paths when prefix limit |
| reached"; | | reached"; |
| } | | } |
| leaf max-prefix-threshold-percent { | | leaf max-prefix-threshold-percent { |
| type uint8; | | type uint8; |
| units "percentage"; | | units "percentage"; |
| description | | description |
| "Percentage of maximum no. of prefixes at which | | "Percentage of maximum no. of prefixes at which |
| to generate warning"; | | to generate warning"; |
| } | | } |
| n | leaf max-prefix-discard-paths-count { | n | |
| type uint32; | | |
| description | | |
| "Number of discarded paths after prefix limit | | |
| reached"; | | |
| } | | |
| leaf max-prefix-restart-time { | | leaf max-prefix-restart-time { |
| type uint16; | | type uint16; |
| units "minute"; | | units "minute"; |
| description | | description |
| "Time interval (in minutes) after which peering | | "Time interval (in minutes) after which peering |
| session will be reestablished"; | | session will be reestablished"; |
| } | | } |
| leaf is-peer-orf-capable { | | leaf is-peer-orf-capable { |
| type boolean; | | type boolean; |
| description | | description |
| "Peer has outbound route filter capability"; | | "Peer has outbound route filter capability"; |
| } | | } |
| leaf is-advertised-orf-send { | | leaf is-advertised-orf-send { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix based ORF send mode capability advertised"; | | "Prefix based ORF send mode capability advertised"; |
| } | | } |
| leaf is-received-orf-send-capable { | | leaf is-received-orf-send-capable { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix based ORF send mode capability received"; | | "Prefix based ORF send mode capability received"; |
| } | | } |
| leaf is-advertised-orf-receive { | | leaf is-advertised-orf-receive { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix based ORF receive mode capability | | "Prefix based ORF receive mode capability |
| advertised"; | | advertised"; |
| } | | } |
| leaf is-received-orf-receive-capable { | | leaf is-received-orf-receive-capable { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix based ORF receive mode capability | | "Prefix based ORF receive mode capability |
| received"; | | received"; |
| } | | } |
| leaf is-advertised-graceful-restart { | | leaf is-advertised-graceful-restart { |
| type boolean; | | type boolean; |
| description | | description |
| "Graceful Restart Capability advertised"; | | "Graceful Restart Capability advertised"; |
| } | | } |
| leaf is-graceful-restart-state-flag { | | leaf is-graceful-restart-state-flag { |
| type boolean; | | type boolean; |
| description | | description |
| "Restart state flag enabled"; | | "Restart state flag enabled"; |
| } | | } |
| leaf is-received-graceful-restart-capable { | | leaf is-received-graceful-restart-capable { |
| type boolean; | | type boolean; |
| description | | description |
| "Graceful Restart Capability received"; | | "Graceful Restart Capability received"; |
| } | | } |
| leaf is-add-path-send-capability-advertised { | | leaf is-add-path-send-capability-advertised { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if addpath send capability is | n | "Addpath Send capability advertised"; |
| advertised"; | | |
| } | | } |
| leaf is-add-path-send-capability-received { | | leaf is-add-path-send-capability-received { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if addpath send capability is | n | "Addpath Send capability received"; |
| received"; | | |
| } | | } |
| leaf is-add-path-receive-capability-advertised { | | leaf is-add-path-receive-capability-advertised { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate whetheraddpath receive | n | |
| capabilityadvertised"; | | "Addpath Receive capability advertised"; |
| } | | } |
| leaf is-add-path-receive-capability-received { | | leaf is-add-path-receive-capability-received { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate whether addpathreceive | n | |
| capability received"; | | "Addpath Receive capability received"; |
| } | | } |
| leaf restart-time { | | leaf restart-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Restart time advertised (seconds)"; | | "Restart time advertised (seconds)"; |
| } | | } |
| leaf local-restart-time { | | leaf local-restart-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Local Restart time (seconds)"; | | "Local Restart time (seconds)"; |
| } | | } |
| leaf stale-path-timeout { | | leaf stale-path-timeout { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Stale path timeout time (in seconds)"; | | "Stale path timeout time (in seconds)"; |
| } | | } |
| leaf rib-purge-timeout-value { | | leaf rib-purge-timeout-value { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "RIB purge timeout time (in seconds)"; | | "RIB purge timeout time (in seconds)"; |
| } | | } |
| leaf neighbor-preserved-forwarding-state { | | leaf neighbor-preserved-forwarding-state { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if BGP neighbor is preserved in | n | "Neighbor preserved forwarding state"; |
| forwarding state"; | | |
| } | | } |
| leaf long-lived-graceful-restart-stale-time-configured { | | leaf long-lived-graceful-restart-stale-time-configured { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate whether long-lived | n | |
| graceful-restart stale time is configured"; | | "Long-lived graceful-restart stale time is |
| } | | |
| leaf retention-stale-time-configured { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate whether Retention stale time is | | |
| configured"; | | configured"; |
| n | } | n | |
| leaf retention-policy { | | |
| type string; | | |
| description | | |
| "Retention Policy"; | | |
| } | | |
| leaf retention-stale-time { | | |
| type uint32; | | |
| description | | |
| "Stale time Configured for Route Retention"; | | |
| } | | } |
| leaf long-lived-graceful-restart-stale-time-sent { | | leaf long-lived-graceful-restart-stale-time-sent { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Stale time sent in long-lived graceful-restart | | "Stale time sent in long-lived graceful-restart |
| capability (seconds)"; | | capability (seconds)"; |
| } | | } |
| leaf long-lived-graceful-restart-stale-time-accept { | | leaf long-lived-graceful-restart-stale-time-accept { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Maximum long-lived graceful-restart stale time | | "Maximum long-lived graceful-restart stale time |
| acceptable from the neighbor (seconds)"; | | acceptable from the neighbor (seconds)"; |
| } | | } |
| leaf long-lived-graceful-restart-capability-received { | | leaf long-lived-graceful-restart-capability-received { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate whether long-livedgraceful | n | "Long-lived graceful-restart capability received |
| restart capability received from the neighbor"; | | from the neighbor"; |
| } | | } |
| leaf long-lived-graceful-restart-stale-time-received { | | leaf long-lived-graceful-restart-stale-time-received { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Long-lived graceful-restart stale time received | | "Long-lived graceful-restart stale time received |
| from the neighbor (seconds)"; | | from the neighbor (seconds)"; |
| } | | } |
| leaf neighbor-preserved-long-lived-forwarding-state { | | leaf neighbor-preserved-long-lived-forwarding-state { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate whether neighbor preserved | n | |
| long-lived forwarding state"; | | "Neighbor preserved long-lived forwarding state"; |
| } | | } |
| leaf neighbor-long-lived-graceful-restart-capable { | | leaf neighbor-long-lived-graceful-restart-capable { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate whether treat neighbor as | n | "Treat neighbor as long-lived graceful-restart |
| long-lived graceful-restart capable"; | | capable"; |
| } | | } |
| leaf neighbor-long-lived-graceful-restart-time-remaining { | | leaf neighbor-long-lived-graceful-restart-time-remaining { |
| type uint32; | | type uint32; |
| description | | description |
| "Remaining long-lived graceful-restart time"; | | "Remaining long-lived graceful-restart time"; |
| } | | } |
| leaf is-prefix-orf-present { | | leaf is-prefix-orf-present { |
| type boolean; | | type boolean; |
| description | | description |
| "Outbound route filter prefix ORF present"; | | "Outbound route filter prefix ORF present"; |
| } | | } |
| leaf orf-entries-received { | | leaf orf-entries-received { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of outbound route filter entries received"; | | "Number of outbound route filter entries received"; |
| } | | } |
| leaf route-policy-prefix-orf { | | leaf route-policy-prefix-orf { |
| type string; | | type string; |
| description | | description |
| "Prefix based ORF for incoming updates"; | | "Prefix based ORF for incoming updates"; |
| } | | } |
| leaf route-policy-in { | | leaf route-policy-in { |
| type string; | | type string; |
| description | | description |
| "Incoming route policy name"; | | "Incoming route policy name"; |
| } | | } |
| leaf route-policy-out { | | leaf route-policy-out { |
| type string; | | type string; |
| description | | description |
| "Outgoing route policy name"; | | "Outgoing route policy name"; |
| } | | } |
| leaf route-policy-default-originate { | | leaf route-policy-default-originate { |
| type string; | | type string; |
| description | | description |
| "Default-originate route policy name"; | | "Default-originate route policy name"; |
| } | | } |
| leaf is-neighbor-ebgp-without-inbound-policy { | | leaf is-neighbor-ebgp-without-inbound-policy { |
| type boolean; | | type boolean; |
| description | | description |
| "eBGP neighbor with no configured inbound policy"; | | "eBGP neighbor with no configured inbound policy"; |
| } | | } |
| leaf is-neighbor-ebgp-without-outbound-policy { | | leaf is-neighbor-ebgp-without-outbound-policy { |
| type boolean; | | type boolean; |
| description | | description |
| "eBGP neighbor with no configured outbound policy"; | | "eBGP neighbor with no configured outbound policy"; |
| } | | } |
| leaf is-upd-orig-loopchk-disable-set { | | leaf is-upd-orig-loopchk-disable-set { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate for update out originator | n | "upd_orig_loopchk_disable set "; |
| loopcheck disable is set"; | | |
| } | | } |
| leaf is-as-override-set { | | leaf is-as-override-set { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if As-override is set"; | n | "As override set "; |
| } | | } |
| leaf is-allow-as-in-set { | | leaf is-allow-as-in-set { |
| type boolean; | | type boolean; |
| description | | description |
| "Allowas-in set "; | | "Allowas-in set "; |
| } | | } |
| leaf allow-as-in-count { | | leaf allow-as-in-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Allowas-in count config"; | | "Allowas-in count config"; |
| } | | } |
| n | leaf is-allow-confed-as-in-set { | n | |
| type boolean; | | |
| description | | |
| "Allowconfedas-in set "; | | |
| } | | |
| leaf allow-confed-as-in-count { | | |
| type uint32; | | |
| description | | |
| "Allowconfedas-in count config"; | | |
| } | | |
| leaf address-family-long-lived-time { | | leaf address-family-long-lived-time { |
| type uint32; | | type uint32; |
| description | | description |
| "AF specific Long-lived-time config"; | | "AF specific Long-lived-time config"; |
| } | | } |
| leaf is-aigp-set { | | leaf is-aigp-set { |
| type boolean; | | type boolean; |
| description | | description |
| "AIGP set "; | | "AIGP set "; |
| } | | } |
| leaf is-rt-present { | | leaf is-rt-present { |
| type boolean; | | type boolean; |
| description | | description |
| "RT attribute list present"; | | "RT attribute list present"; |
| } | | } |
| leaf is-rt-present-standby { | | leaf is-rt-present-standby { |
| type boolean; | | type boolean; |
| description | | description |
| "RT attribute list present"; | | "RT attribute list present"; |
| } | | } |
| leaf accept-own-enabled { | | leaf accept-own-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if accept-Own is enabled"; | n | "Accept-Own enabled"; |
| } | | } |
| leaf selective-multipath-eligible { | | leaf selective-multipath-eligible { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if selective multipath is | n | "Selective multipath eligible"; |
| eligible"; | | |
| } | | } |
| leaf afrpki-disable { | | leaf afrpki-disable { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix validation disabled"; | | "Prefix validation disabled"; |
| } | | } |
| leaf afrpki-use-validity { | | leaf afrpki-use-validity { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix v. use validity"; | | "Prefix v. use validity"; |
| } | | } |
| leaf afrpki-allow-invalid { | | leaf afrpki-allow-invalid { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix v. allow invalid"; | | "Prefix v. allow invalid"; |
| } | | } |
| leaf afrpki-signal-ibgp { | | leaf afrpki-signal-ibgp { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix v. signal ibgp"; | | "Prefix v. signal ibgp"; |
| } | | } |
| leaf is-advertise-permanent-network { | | leaf is-advertise-permanent-network { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if advertise permanent network | n | "Advertise Permanent Network"; |
| is enabled"; | | |
| } | | } |
| leaf is-send-mcast-attr { | | leaf is-send-mcast-attr { |
| type boolean; | | type boolean; |
| description | | description |
| "Send Mcast Attr"; | | "Send Mcast Attr"; |
| } | | } |
| leaf import-stitching { | | leaf import-stitching { |
| type boolean; | | type boolean; |
| description | | description |
| "Import Stitching enabled"; | | "Import Stitching enabled"; |
| } | | } |
| leaf import-reoriginate { | | leaf import-reoriginate { |
| type boolean; | | type boolean; |
| description | | description |
| "Import Reoriginate enabled"; | | "Import Reoriginate enabled"; |
| } | | } |
| leaf import-reoriginate-stitching { | | leaf import-reoriginate-stitching { |
| type boolean; | | type boolean; |
| description | | description |
| "Import Reoriginate Stitching enabled"; | | "Import Reoriginate Stitching enabled"; |
| } | | } |
| leaf advertise-v4-flags { | | leaf advertise-v4-flags { |
| type uint32; | | type uint32; |
| description | | description |
| "Advertise options for VPNV4"; | | "Advertise options for VPNV4"; |
| } | | } |
| leaf advertise-v6-flags { | | leaf advertise-v6-flags { |
| type uint32; | | type uint32; |
| description | | description |
| "Advertise options for VPNV6"; | | "Advertise options for VPNV6"; |
| } | | } |
| leaf enable-label-stack { | | leaf enable-label-stack { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if label stack is enabled"; | n | "Enable label stack"; |
| } | | } |
| list extended-community { | | list extended-community { |
| description | | description |
| "Extended community attribute"; | | "Extended community attribute"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "Extended community attribute"; | | "Extended community attribute"; |
| } | | } |
| } | | } |
| list extended-community-standby { | | list extended-community-standby { |
| description | | description |
| "Extended community attribute"; | | "Extended community attribute"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "Extended community attribute"; | | "Extended community attribute"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping BGP-NBR-RANGE-BAG { | | grouping BGP-NBR-RANGE-BAG { |
| description | | description |
| "BGP Neighbor Range Information"; | | "BGP Neighbor Range Information"; |
| container connection-local-address { | | container connection-local-address { |
| description | | description |
| "Local address for the connection"; | | "Local address for the connection"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container connection-remote-address { | | container connection-remote-address { |
| description | | description |
| "Remote address for the connection"; | | "Remote address for the connection"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container graceful-maintenance { | | container graceful-maintenance { |
| description | | description |
| n | "BGP connection of graceful shutdown"; | n | "Graceful Maintenance"; |
| uses BGP-NBR-GSHUT; | | uses BGP-NBR-GSHUT; |
| } | | } |
| container cfg-local-address { | | container cfg-local-address { |
| description | | description |
| "Configured local address"; | | "Configured local address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container local-address-subnet { | | container local-address-subnet { |
| description | | description |
| n | "Subnet for the BGP local address"; | n | "local address subnet address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| leaf speaker-id { | | leaf speaker-id { |
| type uint8; | | type uint8; |
| description | | description |
| "Speaker this neighbor is allocated to"; | | "Speaker this neighbor is allocated to"; |
| } | | } |
| leaf description { | | leaf description { |
| type string; | | type string; |
| description | | description |
| n | "Description of the BGP neighbor"; | n | "Description"; |
| } | | } |
| leaf local-as { | | leaf local-as { |
| type uint32; | | type uint32; |
| description | | description |
| "Local AS number"; | | "Local AS number"; |
| } | | } |
| leaf remote-as { | | leaf remote-as { |
| type uint32; | | type uint32; |
| description | | description |
| "Remote AS number"; | | "Remote AS number"; |
| } | | } |
| leaf has-internal-link { | | leaf has-internal-link { |
| type boolean; | | type boolean; |
| description | | description |
| "Internal link to neighbor"; | | "Internal link to neighbor"; |
| } | | } |
| leaf is-local-address-configured { | | leaf is-local-address-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "Local address configured for the neighbor | | "Local address configured for the neighbor |
| connection"; | | connection"; |
| } | | } |
| leaf neighbor-range-prefix-length { | | leaf neighbor-range-prefix-length { |
| type uint8; | | type uint8; |
| description | | description |
| n | "Length of the BGP neighbor prefix"; | n | "Neighbor Range Prefix Length"; |
| } | | } |
| leaf is-administratively-shut-down { | | leaf is-administratively-shut-down { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if neighbor is administratively | n | "Neighbor is administratively shut down"; |
| shutdown"; | | |
| } | | } |
| leaf is-neighbor-max-prefix-shutdown { | | leaf is-neighbor-max-prefix-shutdown { |
| type boolean; | | type boolean; |
| description | | description |
| "Neighbor shut down because it exceeded max prfx | | "Neighbor shut down because it exceeded max prfx |
| count"; | | count"; |
| } | | } |
| leaf is-out-of-memory-forced-up { | | leaf is-out-of-memory-forced-up { |
| type boolean; | | type boolean; |
| description | | description |
| "Neighbor forced up during a low memory condition"; | | "Neighbor forced up during a low memory condition"; |
| } | | } |
| leaf ttl-security-enabled { | | leaf ttl-security-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "TTL Security enabled"; | | "TTL Security enabled"; |
| } | | } |
| leaf suppress4-byte-as { | | leaf suppress4-byte-as { |
| type boolean; | | type boolean; |
| description | | description |
| "Suppress 4byteas capability"; | | "Suppress 4byteas capability"; |
| } | | } |
| leaf bfd-session-enable-mode { | | leaf bfd-session-enable-mode { |
| type Bgp-bfd-enable-mode; | | type Bgp-bfd-enable-mode; |
| description | | description |
| "BFD enable mode for this peer"; | | "BFD enable mode for this peer"; |
| } | | } |
| leaf bfd-minintervalval { | | leaf bfd-minintervalval { |
| type uint32; | | type uint32; |
| description | | description |
| "BFD Mininterval for this peer"; | | "BFD Mininterval for this peer"; |
| } | | } |
| leaf bfd-multiplierval { | | leaf bfd-multiplierval { |
| type uint32; | | type uint32; |
| description | | description |
| "BFD Multiplier for this peer"; | | "BFD Multiplier for this peer"; |
| } | | } |
| leaf ebgp-time-to-live { | | leaf ebgp-time-to-live { |
| type uint32; | | type uint32; |
| description | | description |
| "Maximum number of hops for external BGP neighbor"; | | "Maximum number of hops for external BGP neighbor"; |
| } | | } |
| leaf is-ebgp-multihop-bgp-mpls-forwarding-disabled { | | leaf is-ebgp-multihop-bgp-mpls-forwarding-disabled { |
| type boolean; | | type boolean; |
| description | | description |
| "If true, MPLS and NULL rewrite is disabled; if | | "If true, MPLS and NULL rewrite is disabled; if |
| false, it is enabled"; | | false, it is enabled"; |
| } | | } |
| leaf tcpmss { | | leaf tcpmss { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Neighbor TCP Maximum Segment size"; | n | "Neighbor TCP Maximum Segment |
| } | | size"; |
| leaf tcpmtu { | | |
| type boolean; | | |
| description | | |
| "Neighbor TCP Path MTU Discovery option"; | | |
| } | | } |
| leaf msg-log-in { | | leaf msg-log-in { |
| type uint32; | | type uint32; |
| description | | description |
| "Message in log count"; | | "Message in log count"; |
| } | | } |
| leaf msg-log-out { | | leaf msg-log-out { |
| type uint32; | | type uint32; |
| description | | description |
| "Message out log count"; | | "Message out log count"; |
| } | | } |
| leaf neighbor-local-as { | | leaf neighbor-local-as { |
| type uint32; | | type uint32; |
| description | | description |
| "Local AS configured on the neighbor"; | | "Local AS configured on the neighbor"; |
| } | | } |
| leaf local-as-no-prepend { | | leaf local-as-no-prepend { |
| type boolean; | | type boolean; |
| description | | description |
| "Option to not prepend the Local AS to | | "Option to not prepend the Local AS to |
| announcements"; | | announcements"; |
| } | | } |
| leaf merge-inbound-safi1and4-updates { | | leaf merge-inbound-safi1and4-updates { |
| type boolean; | | type boolean; |
| description | | description |
| "Merge SAFI-1 and SAFI-4 updates from neighbor"; | | "Merge SAFI-1 and SAFI-4 updates from neighbor"; |
| } | | } |
| leaf is-capability-negotiation-performed { | | leaf is-capability-negotiation-performed { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if BGP neighbor capability | n | |
| negotiation is performed"; | | "Capability negotiation performed"; |
| } | | } |
| leaf configured-hold-time { | | leaf configured-hold-time { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "Hold time (in secs) configured for this | | "Hold time (in secs) configured for this |
| connection"; | | connection"; |
| } | | } |
| leaf configured-keepalive { | | leaf configured-keepalive { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "Keepalive time (in secs) configured for this | | "Keepalive time (in secs) configured for this |
| connection"; | | connection"; |
| } | | } |
| leaf configured-min-acc-hold-time { | | leaf configured-min-acc-hold-time { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "Minimum acceptable hold time from neighbor (in | | "Minimum acceptable hold time from neighbor (in |
| secs) configured for this connection"; | | secs) configured for this connection"; |
| } | | } |
| leaf min-advertise-interval { | | leaf min-advertise-interval { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Minimum advertisement interval, secs part"; | | "Minimum advertisement interval, secs part"; |
| } | | } |
| leaf min-advertise-interval-msecs { | | leaf min-advertise-interval-msecs { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Minimum advertisement interval, msecs part"; | | "Minimum advertisement interval, msecs part"; |
| } | | } |
| leaf min-origination-interval { | | leaf min-origination-interval { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "Minimum origination interval (in secs)"; | | "Minimum origination interval (in secs)"; |
| } | | } |
| leaf remote-as-number { | | leaf remote-as-number { |
| type uint32; | | type uint32; |
| description | | description |
| n | "AS number of the neighbor"; | n | "Remote AS number"; |
| } | | } |
| leaf dmz-link-bandwidth { | | leaf dmz-link-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "Bandwidth of link to single-hop eBGP peer"; | | "Bandwidth of link to single-hop eBGP peer"; |
| } | | } |
| leaf ebgp-recv-dmz { | | leaf ebgp-recv-dmz { |
| type boolean; | | type boolean; |
| description | | description |
| "Receive Bandwidth of link to single-hop eBGP | | "Receive Bandwidth of link to single-hop eBGP |
| peer"; | | peer"; |
| } | | } |
| leaf ebgp-send-dmz-mode { | | leaf ebgp-send-dmz-mode { |
| type Bgp-ebgp-send-dmz-enable-mode; | | type Bgp-ebgp-send-dmz-enable-mode; |
| description | | description |
| "Ebgp send dmz link bw mode"; | | "Ebgp send dmz link bw mode"; |
| } | | } |
| leaf tos-type { | | leaf tos-type { |
| type uint8; | | type uint8; |
| description | | description |
| "Precedence or DSCP type"; | | "Precedence or DSCP type"; |
| } | | } |
| leaf tos-value { | | leaf tos-value { |
| type uint8; | | type uint8; |
| description | | description |
| "Precedence or DSCP value"; | | "Precedence or DSCP value"; |
| } | | } |
| leaf tcp-session-open-mode { | | leaf tcp-session-open-mode { |
| type Bgp-tcp-mode; | | type Bgp-tcp-mode; |
| description | | description |
| "The TCP mode to be used to set up BGP session | | "The TCP mode to be used to set up BGP session |
| with the neighbor"; | | with the neighbor"; |
| } | | } |
| leaf vrf-name { | | leaf vrf-name { |
| type string; | | type string; |
| description | | description |
| "Name of the VRF"; | | "Name of the VRF"; |
| } | | } |
| leaf standby-rp { | | leaf standby-rp { |
| type boolean; | | type boolean; |
| description | | description |
| "Standby RP socket inited for Active Open"; | | "Standby RP socket inited for Active Open"; |
| } | | } |
| leaf nsr-enabled { | | leaf nsr-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Neighbor supports NSR"; | | "Neighbor supports NSR"; |
| } | | } |
| leaf graceful-restart-enabled-nbr { | | leaf graceful-restart-enabled-nbr { |
| type boolean; | | type boolean; |
| description | | description |
| "Neighbor supports graceful-restart"; | | "Neighbor supports graceful-restart"; |
| } | | } |
| n | leaf graceful-restart-helper-mode { | n | |
| type boolean; | | |
| description | | |
| "Neighbor supports graceful-restart in | | |
| helper-mode"; | | |
| } | | |
| leaf gr-restart-time { | | leaf gr-restart-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Neighbor restart time (in seconds)"; | | "Neighbor restart time (in seconds)"; |
| } | | } |
| leaf gr-stale-path-time { | | leaf gr-stale-path-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Neighbor stale-path time (in seconds)"; | | "Neighbor stale-path time (in seconds)"; |
| } | | } |
| leaf is-passive-close { | | leaf is-passive-close { |
| type boolean; | | type boolean; |
| description | | description |
| "If true, active socket canbe closed if passive | | "If true, active socket canbe closed if passive |
| openis received for a GRcapable neighbor"; | | openis received for a GRcapable neighbor"; |
| } | | } |
| leaf nbr-enforce-first-as { | | leaf nbr-enforce-first-as { |
| type boolean; | | type boolean; |
| description | | description |
| "Neighbor enforce first AS"; | | "Neighbor enforce first AS"; |
| } | | } |
| leaf active-bmp-servers { | | leaf active-bmp-servers { |
| type uint8; | | type uint8; |
| description | | description |
| "BMP Servers to which the neighbor sends logs"; | | "BMP Servers to which the neighbor sends logs"; |
| } | | } |
| leaf nbr-cluster-id { | | leaf nbr-cluster-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Cluster id"; | | "Cluster id"; |
| } | | } |
| leaf nbr-in-cluster { | | leaf nbr-in-cluster { |
| type uint8; | | type uint8; |
| description | | description |
| "Type of cluster_id:undefined/number/Ip address"; | | "Type of cluster_id:undefined/number/Ip address"; |
| } | | } |
| leaf ignore-connected { | | leaf ignore-connected { |
| type boolean; | | type boolean; |
| description | | description |
| "If true, the VPN client isan IBGP CE peer"; | | "If true, the VPN client isan IBGP CE peer"; |
| } | | } |
| leaf internal-vpn-client { | | leaf internal-vpn-client { |
| type boolean; | | type boolean; |
| description | | description |
| "If true, don't do NHconnected check for nbr"; | | "If true, don't do NHconnected check for nbr"; |
| } | | } |
| leaf local-as-replace-as { | | leaf local-as-replace-as { |
| type boolean; | | type boolean; |
| description | | description |
| "Local AS Replace-AS option"; | | "Local AS Replace-AS option"; |
| } | | } |
| leaf local-as-dual-as { | | leaf local-as-dual-as { |
| type boolean; | | type boolean; |
| description | | description |
| "Local AS Dual-AS option"; | | "Local AS Dual-AS option"; |
| } | | } |
| leaf local-as-dual-as-mode-native { | | leaf local-as-dual-as-mode-native { |
| type boolean; | | type boolean; |
| description | | description |
| "Applies only if Local AS Dual-AS option is | | "Applies only if Local AS Dual-AS option is |
| enabled. Indicates if Dual-AS mode is native."; | | enabled. Indicates if Dual-AS mode is native."; |
| } | | } |
| leaf egress-peer-engineering-enabled { | | leaf egress-peer-engineering-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates if Egress Peer Engineering is enabled"; | | "Indicates if Egress Peer Engineering is enabled"; |
| } | | } |
| leaf discard-as4-path { | | leaf discard-as4-path { |
| type uint32; | | type uint32; |
| description | | description |
| "Discard AS4_PATH in case there is a discrepancy | | "Discard AS4_PATH in case there is a discrepancy |
| in merging AS_PATH and AS4_PATH,retain ASPATH"; | | in merging AS_PATH and AS4_PATH,retain ASPATH"; |
| } | | } |
| leaf rpki-disable { | | leaf rpki-disable { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix validation disabled"; | | "Prefix validation disabled"; |
| } | | } |
| leaf rpki-use-validity { | | leaf rpki-use-validity { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix v. use validity"; | | "Prefix v. use validity"; |
| } | | } |
| leaf rpki-allow-invalid { | | leaf rpki-allow-invalid { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix v. allow invalid"; | | "Prefix v. allow invalid"; |
| } | | } |
| leaf rpki-signal-ibgp { | | leaf rpki-signal-ibgp { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix v. signal ibgp"; | | "Prefix v. signal ibgp"; |
| } | | } |
| leaf remote-as-list-name { | | leaf remote-as-list-name { |
| type string; | | type string; |
| description | | description |
| "Remote AS List Name"; | | "Remote AS List Name"; |
| } | | } |
| leaf nbr-rcv-size { | | leaf nbr-rcv-size { |
| type uint32; | | type uint32; |
| description | | description |
| "Nbr Receive Size"; | | "Nbr Receive Size"; |
| } | | } |
| leaf nbr-send-size { | | leaf nbr-send-size { |
| type uint32; | | type uint32; |
| description | | description |
| "Nbr Send Size"; | | "Nbr Send Size"; |
| } | | } |
| leaf islocal-address-cfg { | | leaf islocal-address-cfg { |
| type boolean; | | type boolean; |
| description | | description |
| "Local address configured"; | | "Local address configured"; |
| } | | } |
| leaf update-source { | | leaf update-source { |
| type string; | | type string; |
| description | | description |
| n | "Interface to get the local IP address for the | n | "Update Source"; |
| BGP session"; | | |
| } | | } |
| leaf is-local-addr-subnet-cfg { | | leaf is-local-addr-subnet-cfg { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if local-address-subnet is | n | "local-address-subnet configured"; |
| configured"; | | |
| } | | } |
| leaf local-address-subnet-len { | | leaf local-address-subnet-len { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Length of subnet for BGP local address"; | n | "local address subnet address len"; |
| } | | } |
| leaf addpath-send-enable { | | leaf addpath-send-enable { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if addpath send functionality | n | "Addpath Send enabled"; |
| is enabled"; | | |
| } | | } |
| leaf addpath-receive-enable { | | leaf addpath-receive-enable { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if addpath receive | n | "Addpath Receive enable"; |
| functionality is enabled"; | | |
| } | | } |
| leaf addpath-send-disable { | | leaf addpath-send-disable { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate addpath send functionality is | n | "Addpath Send Disabled"; |
| disabled"; | | |
| } | | } |
| leaf addpath-receive-disable { | | leaf addpath-receive-disable { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag indicates if addpath receive functionality | n | "Addpath Receive Disabled"; |
| is disabled"; | | |
| } | | } |
| leaf upd-errh-noreset { | | leaf upd-errh-noreset { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Update error handling as avoid-reset to errros "; | n | "Update errh noreset"; |
| } | | } |
| leaf msg-buf-count { | | leaf msg-buf-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Message Buf Count"; | | "Message Buf Count"; |
| } | | } |
| leaf msg-bug-circular { | | leaf msg-bug-circular { |
| type boolean; | | type boolean; |
| description | | description |
| "Message Buf Circular"; | | "Message Buf Circular"; |
| } | | } |
| leaf syslog-enable { | | leaf syslog-enable { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if syslog should be output when | n | "syslog enable"; |
| an attribute filter is executed"; | | |
| } | | } |
| leaf oper-attrf-enable { | | leaf oper-attrf-enable { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if operational attribute filter | n | "Oper attrf Enable"; |
| is enabled"; | | |
| } | | } |
| leaf attrf-group-name { | | leaf attrf-group-name { |
| type string; | | type string; |
| description | | description |
| n | "Name of the attribute filter group Name"; | n | "Attrf Group Name"; |
| } | | } |
| leaf max-peers { | | leaf max-peers { |
| type uint32; | | type uint32; |
| description | | description |
| "Max Dynamic nbrs in range"; | | "Max Dynamic nbrs in range"; |
| } | | } |
| leaf idle-watch-time { | | leaf idle-watch-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Dynamic Neighbor idle-watch time (in seconds)"; | | "Dynamic Neighbor idle-watch time (in seconds)"; |
| } | | } |
| leaf current-peers { | | leaf current-peers { |
| type uint32; | | type uint32; |
| description | | description |
| "Current Dynamic nbrs in range"; | | "Current Dynamic nbrs in range"; |
| } | | } |
| leaf range-open-match { | | leaf range-open-match { |
| type uint32; | | type uint32; |
| description | | description |
| "Passive open matching range"; | | "Passive open matching range"; |
| } | | } |
| leaf range-open-accepted { | | leaf range-open-accepted { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP neighbor passive session accepted"; | n | "open accepted"; |
| } | | } |
| leaf range-max-drop { | | leaf range-max-drop { |
| type uint32; | | type uint32; |
| description | | description |
| "open drop due to max peers"; | | "open drop due to max peers"; |
| } | | } |
| leaf range-inst-error { | | leaf range-inst-error { |
| type uint32; | | type uint32; |
| description | | description |
| "Error during instance creation"; | | "Error during instance creation"; |
| n | } | n | |
| leaf update-error-handling-treat-as-withdraw { | | |
| type boolean; | | |
| description | | |
| "Update error handling as treat-as-withdrawto | | |
| errors"; | | |
| } | | |
| leaf allow-as-in { | | |
| type uint32; | | |
| description | | |
| "Number of Own AS numbers allowed in inbound | | |
| update"; | | |
| } | | |
| leaf sent-community-to-neighbor { | | |
| type boolean; | | |
| description | | |
| "Community attribute sent toneighbor"; | | |
| } | | |
| leaf sent-extended-community-to-neighbor { | | |
| type boolean; | | |
| description | | |
| "Extended Communityattribute sent to neighbor"; | | |
| } | | |
| leaf dampeniing { | | |
| type Bgp-nbr-dampening; | | |
| description | | |
| "neighbor dampening"; | | |
| } | | |
| leaf is-as-override-disabled { | | |
| type Bgp-nbr-aspath-as-override; | | |
| description | | |
| "Disable as override"; | | |
| } | | |
| leaf nbr-disable-peer-as { | | |
| type Bgp-nbr-disable-peer-as; | | |
| description | | |
| "Neighbor Disable Peer AS"; | | |
| } | | |
| leaf gbl-disable-peer-as-enable { | | |
| type boolean; | | |
| description | | |
| "Global Disable Peer AS Enable"; | | |
| } | | |
| leaf nbr-fast-fallover { | | |
| type boolean; | | |
| description | | |
| "BGP neighbor will go down if its directly | | |
| connected interface goes down"; | | |
| } | | |
| leaf ipfwd-preferred { | | |
| type boolean; | | |
| description | | |
| "Prefer to send BGP control packets on IP"; | | |
| } | | |
| leaf skip-read-count { | | |
| type uint32; | | |
| description | | |
| "Skip Read count"; | | |
| } | | } |
| list af-data { | | list af-data { |
| max-elements "25"; | | max-elements "25"; |
| description | | description |
| "Address family specific neighbor data"; | | "Address family specific neighbor data"; |
| uses BGP-NBR-RANGE-AF; | | uses BGP-NBR-RANGE-AF; |
| } | | } |
| list instance { | | list instance { |
| description | | description |
| "Dynamic Neighbor Instance List"; | | "Dynamic Neighbor Instance List"; |
| uses BGP-NBR-INSTANCE; | | uses BGP-NBR-INSTANCE; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-NEXTHOP-VRF-BAG { | | grouping BGP-NEXTHOP-VRF-BAG { |
| description | | description |
| "BGP nexthop processing information for a VRF"; | | "BGP nexthop processing information for a VRF"; |
| leaf total-processing-time { | | leaf total-processing-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Total time spent in processing"; | | "Total time spent in processing"; |
| } | | } |
| leaf max-proc-notification-time { | | leaf max-proc-notification-time { |
| type uint32; | | type uint32; |
| description | | description |
| "How long since the maximum processing time | | "How long since the maximum processing time |
| notifcation was received"; | | notifcation was received"; |
| } | | } |
| leaf max-notification-bestpath-deletes { | | leaf max-notification-bestpath-deletes { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of bestpath deletes caused by | | "Number of bestpath deletes caused by |
| notification which resulted in maximum | | notification which resulted in maximum |
| processing"; | | processing"; |
| } | | } |
| leaf max-notification-bestpath-changes { | | leaf max-notification-bestpath-changes { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of bestpath changes caused by | | "Number of bestpath changes caused by |
| notification which resulted in maximum | | notification which resulted in maximum |
| processing"; | | processing"; |
| } | | } |
| leaf maximum-processing-time { | | leaf maximum-processing-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Maximum time spent procesing a single batch | | "Maximum time spent procesing a single batch |
| notification"; | | notification"; |
| } | | } |
| leaf last-notificationication-time { | | leaf last-notificationication-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Time since the last notification was received"; | | "Time since the last notification was received"; |
| } | | } |
| leaf last-notification-processing-time { | | leaf last-notification-processing-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Processing time for the last notification"; | | "Processing time for the last notification"; |
| } | | } |
| } | | } |
| | | |
| n | | n | grouping BGP-NBR-BRIEF-BAG { |
| | | description |
| | | "BGP Neighbor brief Information"; |
| | | container connection-local-address { |
| | | description |
| | | "Local address for the connection"; |
| | | uses BGP-ADDRTYPE; |
| | | } |
| | | container connection-remote-address { |
| | | description |
| | | "Remote address for the connection"; |
| | | uses BGP-ADDRTYPE; |
| | | } |
| | | leaf speaker-id { |
| | | type uint8; |
| | | description |
| | | "Speaker this neighbor is allocated to"; |
| | | } |
| | | leaf description { |
| | | type string; |
| | | description |
| | | "Description"; |
| | | } |
| | | leaf local-as { |
| | | type uint32; |
| | | description |
| | | "Local AS number"; |
| | | } |
| | | leaf remote-as { |
| | | type uint32; |
| | | description |
| | | "Remote AS number"; |
| | | } |
| | | leaf messages-queued-in { |
| | | type uint32; |
| | | description |
| | | "No. of msgs on receive queue"; |
| | | } |
| | | leaf messages-queued-out { |
| | | type uint32; |
| | | description |
| | | "No. of messages on send queue"; |
| | | } |
| | | leaf connection-state { |
| | | type Bgp-conn-state; |
| | | description |
| | | "State of connection"; |
| | | } |
| | | leaf is-local-address-configured { |
| | | type boolean; |
| | | description |
| | | "Local address configured for the neighbor |
| | | connection"; |
| | | } |
| | | leaf vrf-name { |
| | | type string; |
| | | description |
| | | "Name of the VRF"; |
| | | } |
| | | leaf nsr-enabled { |
| | | type boolean; |
| | | description |
| | | "Neighbor supports NSR"; |
| | | } |
| | | leaf nsr-state { |
| | | type Bgp-sync-nbr-nsr-state; |
| | | description |
| | | "NSR state"; |
| | | } |
| | | leaf postit-pending { |
| | | type boolean; |
| | | description |
| | | "Nbr has postits pending"; |
| | | } |
| | | } |
| | | |
| grouping BGP-PERF-PROCESS-VRF { | | grouping BGP-PERF-PROCESS-VRF { |
| description | | description |
| "BGP PERF PROCESS VRF"; | | "BGP PERF PROCESS VRF"; |
| leaf lpts-set-up-time { | | leaf lpts-set-up-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Time spent setting up LPTS socket opt (ms)"; | | "Time spent setting up LPTS socket opt (ms)"; |
| } | | } |
| leaf lpts-calls { | | leaf lpts-calls { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of times LPTS socket opt set up"; | | "Number of times LPTS socket opt set up"; |
| } | | } |
| leaf read-throttles-count { | | leaf read-throttles-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of partial read throttles"; | | "Number of partial read throttles"; |
| } | | } |
| leaf low-throttled-read-count { | | leaf low-throttled-read-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of socket reads for nbrs above low | | "Number of socket reads for nbrs above low |
| threshold"; | | threshold"; |
| } | | } |
| leaf high-throttled-read-count { | | leaf high-throttled-read-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of socket reads for nbrs above high | | "Number of socket reads for nbrs above high |
| threshold"; | | threshold"; |
| } | | } |
| leaf read-calls-count { | | leaf read-calls-count { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of calls to function to read inbound data"; | | "No. of calls to function to read inbound data"; |
| } | | } |
| leaf read-messages-count { | | leaf read-messages-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of BGP messages read"; | | "Number of BGP messages read"; |
| } | | } |
| leaf data-bytes-read { | | leaf data-bytes-read { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "No. of bytes of data read"; | | "No. of bytes of data read"; |
| } | | } |
| leaf io-read-time { | | leaf io-read-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Time spent reading inbound data (ms)"; | | "Time spent reading inbound data (ms)"; |
| } | | } |
| leaf write-calls-count { | | leaf write-calls-count { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of calls to function to write outbound data"; | | "No. of calls to function to write outbound data"; |
| } | | } |
| leaf data-bytes-written { | | leaf data-bytes-written { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Number of bytes of data written"; | | "Number of bytes of data written"; |
| } | | } |
| leaf io-write-time { | | leaf io-write-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Time spent writing outbound data (ms)"; | | "Time spent writing outbound data (ms)"; |
| } | | } |
| leaf write-subgroup-calls-count { | | leaf write-subgroup-calls-count { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of calls to to funvction to process | | "No. of calls to to funvction to process |
| sub-group message list"; | | sub-group message list"; |
| } | | } |
| leaf write-subgroup-messages-count { | | leaf write-subgroup-messages-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of sub-group messages processed"; | | "Number of sub-group messages processed"; |
| } | | } |
| leaf subgroup-list-time { | | leaf subgroup-list-time { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Time spent processing sub-group message list | | "Time spent processing sub-group message list |
| (milliseconds)"; | | (milliseconds)"; |
| } | | } |
| leaf write-queue-calls-count { | | leaf write-queue-calls-count { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of Calls to function to process write queue"; | | "No. of Calls to function to process write queue"; |
| } | | } |
| leaf write-queue-messages-count { | | leaf write-queue-messages-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of write queue messages processed"; | | "Number of write queue messages processed"; |
| } | | } |
| leaf write-queue-time { | | leaf write-queue-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Time spent processing write queue (ms)"; | | "Time spent processing write queue (ms)"; |
| } | | } |
| leaf inbound-update-messages { | | leaf inbound-update-messages { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of inbound update messages processed"; | | "Number of inbound update messages processed"; |
| } | | } |
| leaf inbound-update-messages-time { | | leaf inbound-update-messages-time { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Time spent processing imbound update messages | | "Time spent processing imbound update messages |
| (milliseconds)"; | | (milliseconds)"; |
| n | } | n | |
| leaf read-throttled-nbr-count { | | |
| type uint32; | | |
| description | | |
| "Number of neighbors currently throttled for | | |
| reading"; | | |
| } | | |
| leaf max-read-throttled-nbrs { | | |
| type uint32; | | |
| description | | |
| "Maximum Number of neighbors that were throttled | | |
| for reading"; | | |
| } | | |
| leaf max-read-throttled-nbrs-time { | | |
| type uint64; | | |
| description | | |
| "Time when Maximum Number of neighbors were | | |
| throttled for reading"; | | |
| } | | |
| leaf write-throttled-nbr-count { | | |
| type uint32; | | |
| description | | |
| "Number of neighbors currently throttled for | | |
| writing"; | | |
| } | | |
| leaf max-write-throttled-nbrs { | | |
| type uint32; | | |
| description | | |
| "Maximum Number of neighbors that were throttled | | |
| for writing"; | | |
| } | | |
| leaf max-write-throttled-nbrs-time { | | |
| type uint64; | | |
| description | | |
| "Time when Maximum Number of neighbors were | | |
| throttled for writing"; | | |
| } | | |
| leaf write-throttles-count { | | |
| type uint32; | | |
| description | | |
| "Number of write throttles"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-NSR-RECV-STATS-INFO { | | |
| description | | |
| "BGP NSR RECV STATS INFO"; | | |
| container start-time { | | |
| description | | |
| "Start Time"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container end-time { | | |
| description | | |
| "End Time"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| leaf interval { | | |
| type uint32; | | |
| description | | |
| "Time Interval"; | | |
| } | | |
| leaf packet-count { | | |
| type uint32; | | |
| description | | |
| "Number of packets"; | | |
| } | | |
| leaf start-seq { | | |
| type uint32; | | |
| description | | |
| "Start Sequence number"; | | |
| } | | |
| leaf end-seq { | | |
| type uint32; | | |
| description | | |
| "End Sequence number"; | | |
| } | | |
| leaf avg-time { | | |
| type uint64; | | |
| description | | |
| "Avg Time"; | | |
| } | | } |
| } | | } |
| | | |
| grouping BGP-ISSU-MILESTONE-BAG { | | grouping BGP-ISSU-MILESTONE-BAG { |
| description | | description |
| "BGP ISSU MILESTONE BAG"; | | "BGP ISSU MILESTONE BAG"; |
| leaf milestone-name { | | leaf milestone-name { |
| type string; | | type string; |
| description | | description |
| n | "Name of the in-service software upgrade (ISSU) | n | |
| milestone"; | | "Milestone name"; |
| } | | } |
| leaf milestone-start-timestamp { | | leaf milestone-start-timestamp { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Timestamp for the ISSU milestone start"; | n | "Milestone start timestamp"; |
| } | | } |
| leaf milestone-met-timestamp { | | leaf milestone-met-timestamp { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Timestamp when ISSU milestone met"; | n | "Milestone met timestamp"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-PERF-NPL-ENDP-INFO-BAG { | | grouping BGP-PERF-NPL-ENDP-INFO-BAG { |
| description | | description |
| "BGP PERF NPL ENDP INFO BAG"; | | "BGP PERF NPL ENDP INFO BAG"; |
| leaf endpoint-name { | | leaf endpoint-name { |
| type string; | | type string; |
| description | | description |
| n | "BGP NPL endpoint name"; | n | "Endpoint name"; |
| } | | } |
| leaf sync-group-name { | | leaf sync-group-name { |
| type string; | | type string; |
| description | | description |
| "Syncgroup associated with this endpoint"; | | "Syncgroup associated with this endpoint"; |
| } | | } |
| leaf node-id { | | leaf node-id { |
| type xr:Node-id; | | type xr:Node-id; |
| description | | description |
| "Node ID"; | | "Node ID"; |
| } | | } |
| leaf endpoint-handle { | | leaf endpoint-handle { |
| type uint64; | | type uint64; |
| description | | description |
| n | "Handle to end-point for NCD communication"; | n | "NCD endpoint handle"; |
| } | | } |
| leaf endpoint-stale-flag { | | leaf endpoint-stale-flag { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if endpoint is stale"; | n | "Endpoint stale flag"; |
| } | | } |
| leaf endpoint-issu-role { | | leaf endpoint-issu-role { |
| type string; | | type string; |
| description | | description |
| "Endpoint's ISSU Role. Values are 'Primary', | | "Endpoint's ISSU Role. Values are 'Primary', |
| 'Secondary' and 'Tertiary'"; | | 'Secondary' and 'Tertiary'"; |
| } | | } |
| leaf endpoint-active-flag { | | leaf endpoint-active-flag { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if endpoint is active"; | n | "Endpoint active flag"; |
| } | | } |
| leaf msg-size { | | leaf msg-size { |
| type uint32; | | type uint32; |
| description | | description |
| "Message size for this entity"; | | "Message size for this entity"; |
| } | | } |
| leaf wheel-id { | | leaf wheel-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Wheel ID for this endpoint"; | | "Wheel ID for this endpoint"; |
| } | | } |
| leaf expected-sequence-num { | | leaf expected-sequence-num { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP NPL sequence number expected"; | n | "Expected sequence number"; |
| } | | |
| leaf last-sent-sequence-num { | | |
| type uint32; | | |
| description | | |
| "Last sent Sequence Num"; | | |
| } | | |
| leaf npl-initial-sequence-num { | | |
| type uint32; | | |
| description | | |
| "NPL Initial Sequence Num"; | | |
| } | | } |
| list endpoint { | | list endpoint { |
| description | | description |
| "NCD endpoint bytestream"; | | "NCD endpoint bytestream"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| units "byte"; | | units "byte"; |
| description | | description |
| "NCD endpoint bytestream"; | | "NCD endpoint bytestream"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping NSR-PL-RECV-DROP-ARRAY { | | grouping NSR-PL-RECV-DROP-ARRAY { |
| description | | description |
| n | "Drop count while receiving messages"; | n | "NSR PL RECV DROP ARRAY"; |
| list nsr-pl-recv-drop-array { | | list nsr-pl-recv-drop-array { |
| max-elements "16"; | | max-elements "16"; |
| description | | description |
| "nsr pl recv drop array"; | | "nsr pl recv drop array"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| n | "entry"; | n | "nsr pl recv drop array"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping NSR-PL-SEND-DROP-ARRAY { | | grouping NSR-PL-SEND-DROP-ARRAY { |
| description | | description |
| n | "Drop count while sending messages"; | n | "NSR PL SEND DROP ARRAY"; |
| list nsr-pl-send-drop-array { | | list nsr-pl-send-drop-array { |
| max-elements "7"; | | max-elements "7"; |
| description | | description |
| "nsr pl send drop array"; | | "nsr pl send drop array"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| n | "entry"; | n | "nsr pl send drop array"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping NSR-PL-CLIENT-STATS-TYPE { | | grouping NSR-PL-CLIENT-STATS-TYPE { |
| description | | description |
| "NSR PL stats information"; | | "NSR PL stats information"; |
| n | leaf prio-queue-level { | n | |
| type string { | | |
| length "0..32"; | | |
| } | | |
| description | | |
| "npl priority queue level"; | | |
| } | | |
| list num-sent { | | list num-sent { |
| max-elements "5"; | | max-elements "5"; |
| description | | description |
| "Total sent"; | | "Total sent"; |
| leaf entry { | | leaf entry { |
| type uint64; | | type uint64; |
| description | | description |
| "Total sent"; | | "Total sent"; |
| } | | } |
| } | | } |
| list num-recv { | | list num-recv { |
| max-elements "6"; | | max-elements "6"; |
| description | | description |
| "Total recvd"; | | "Total recvd"; |
| leaf entry { | | leaf entry { |
| type uint64; | | type uint64; |
| description | | description |
| "Total recvd"; | | "Total recvd"; |
| } | | } |
| } | | } |
| list num-sent-drop { | | list num-sent-drop { |
| max-elements "5"; | | max-elements "5"; |
| description | | description |
| "Sent Error/drops"; | | "Sent Error/drops"; |
| uses NSR-PL-SEND-DROP-ARRAY; | | uses NSR-PL-SEND-DROP-ARRAY; |
| } | | } |
| list num-recv-drop { | | list num-recv-drop { |
| max-elements "6"; | | max-elements "6"; |
| description | | description |
| "Recv Errors/drops"; | | "Recv Errors/drops"; |
| uses NSR-PL-RECV-DROP-ARRAY; | | uses NSR-PL-RECV-DROP-ARRAY; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-PERF-DS-NPL-INFO-BAG { | | grouping BGP-PERF-DS-NPL-INFO-BAG { |
| description | | description |
| "BGP PERF DS NPL INFO BAG"; | | "BGP PERF DS NPL INFO BAG"; |
| leaf dir-service-conn-state { | | leaf dir-service-conn-state { |
| type Bgp-ds-conn-state; | | type Bgp-ds-conn-state; |
| description | | description |
| "Current Directory Service connectionstate"; | | "Current Directory Service connectionstate"; |
| } | | } |
| leaf issu-mgr-conn-state { | | leaf issu-mgr-conn-state { |
| type Bgp-ism-conn-state; | | type Bgp-ism-conn-state; |
| description | | description |
| "Current ISSU Mgr connection state"; | | "Current ISSU Mgr connection state"; |
| } | | } |
| leaf issu-phase { | | leaf issu-phase { |
| type string; | | type string; |
| description | | description |
| "Current ISSU Phase"; | | "Current ISSU Phase"; |
| } | | } |
| leaf issu-type-ng { | | leaf issu-type-ng { |
| type boolean; | | type boolean; |
| description | | description |
| "ISSU type is Next Gen"; | | "ISSU type is Next Gen"; |
| } | | } |
| leaf issuha-option { | | leaf issuha-option { |
| type string; | | type string; |
| description | | description |
| "Current ISSU HA option"; | | "Current ISSU HA option"; |
| } | | } |
| leaf local-ds-handle { | | leaf local-ds-handle { |
| type uint64; | | type uint64; |
| description | | description |
| "Local Directory Service handle"; | | "Local Directory Service handle"; |
| } | | } |
| leaf service-name { | | leaf service-name { |
| type string; | | type string; |
| description | | description |
| "Local DS service name"; | | "Local DS service name"; |
| } | | } |
| leaf dsissu-status-flag { | | leaf dsissu-status-flag { |
| type uint32; | | type uint32; |
| description | | description |
| "DS ISSU status flag"; | | "DS ISSU status flag"; |
| } | | } |
| list npl-priority-statistic { | | list npl-priority-statistic { |
| max-elements "2"; | | max-elements "2"; |
| description | | description |
| n | "Stats for BGP NPL priority"; | n | "NPL priority statistics"; |
| uses NSR-PL-CLIENT-STATS-TYPE; | | uses NSR-PL-CLIENT-STATS-TYPE; |
| } | | } |
| list npl-endpoint { | | list npl-endpoint { |
| description | | description |
| "NPL endpoint information"; | | "NPL endpoint information"; |
| uses BGP-PERF-NPL-ENDP-INFO-BAG; | | uses BGP-PERF-NPL-ENDP-INFO-BAG; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-PERF-SERVER-CONN-STAT-BAG { | | grouping BGP-PERF-SERVER-CONN-STAT-BAG { |
| description | | description |
| "BGP PERF SERVER CONN STAT BAG"; | | "BGP PERF SERVER CONN STAT BAG"; |
| container first-connection-up-timestamp { | | container first-connection-up-timestamp { |
| description | | description |
| n | "Timestamp for first connection up"; | n | "First connection Up event timestamp"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-connection-up-timestamp { | | container last-connection-up-timestamp { |
| description | | description |
| n | "Timestamp for last connection Up"; | n | "Last connection Up event timestamp"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container first-connection-down-timestamp { | | container first-connection-down-timestamp { |
| description | | description |
| n | "Timestamp for first connection down"; | n | "First connection Down event timestamp"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-connection-down-timestamp { | | container last-connection-down-timestamp { |
| description | | description |
| n | "Timestamp for last connection down"; | n | "Last connection Down event timestamp"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| leaf is-connection-up { | | leaf is-connection-up { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Connection Up?"; | | "Is Connection Up?"; |
| } | | } |
| leaf connection-up-count { | | leaf connection-up-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of connection Up events"; | | "Number of connection Up events"; |
| } | | } |
| leaf last-connection-up-age { | | leaf last-connection-up-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last connection Up event (in seconds)"; | | "Time since last connection Up event (in seconds)"; |
| } | | } |
| leaf connection-down-count { | | leaf connection-down-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of connection down events"; | | "Number of connection down events"; |
| } | | } |
| leaf last-connection-down-age { | | leaf last-connection-down-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last connection Down event (in | | "Time since last connection Down event (in |
| seconds)"; | | seconds)"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-PERF-RIB-GBL-INFO-BAG { | | grouping BGP-PERF-RIB-GBL-INFO-BAG { |
| description | | description |
| "BGP PERF RIB GBL INFO BAG"; | | "BGP PERF RIB GBL INFO BAG"; |
| container first-rib-connection-up-timestamp { | | container first-rib-connection-up-timestamp { |
| description | | description |
| "First RIB connection Up event timestamp"; | | "First RIB connection Up event timestamp"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-rib-connection-up-timestamp { | | container last-rib-connection-up-timestamp { |
| description | | description |
| "Last RIB connection Up event timestamp"; | | "Last RIB connection Up event timestamp"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container first-rib-connection-down-timestamp { | | container first-rib-connection-down-timestamp { |
| description | | description |
| "First RIB connection Down event timestamp"; | | "First RIB connection Down event timestamp"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-rib-connection-down-timestamp { | | container last-rib-connection-down-timestamp { |
| description | | description |
| "Last RIB connection Down event timestamp"; | | "Last RIB connection Down event timestamp"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| leaf is-rib-connection-up { | | leaf is-rib-connection-up { |
| type boolean; | | type boolean; |
| description | | description |
| "Is RIB Connection Up?"; | | "Is RIB Connection Up?"; |
| } | | } |
| leaf rib-connection-up-count { | | leaf rib-connection-up-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of RIB connection Up events"; | | "Number of RIB connection Up events"; |
| } | | } |
| leaf last-rib-connection-up-age { | | leaf last-rib-connection-up-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last RIB connection Up event (in | | "Time since last RIB connection Up event (in |
| seconds)"; | | seconds)"; |
| } | | } |
| leaf rib-connection-down-count { | | leaf rib-connection-down-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of RIB connection Down events"; | | "Number of RIB connection Down events"; |
| } | | } |
| leaf last-rib-connection-down-age { | | leaf last-rib-connection-down-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last RIB connection Down event (in | | "Time since last RIB connection Down event (in |
| seconds)"; | | seconds)"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-POSTIT-COUNT-INFO { | | grouping BGP-POSTIT-COUNT-INFO { |
| description | | description |
| "BGP POSTIT COUNT INFO"; | | "BGP POSTIT COUNT INFO"; |
| container neighbor-address { | | container neighbor-address { |
| description | | description |
| n | "IP address of the neighbor"; | n | "Neighbor Address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| leaf postit-count { | | leaf postit-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Count of the number of postits for this nbr"; | | "Count of the number of postits for this nbr"; |
| } | | } |
| leaf vrf-name { | | leaf vrf-name { |
| type string; | | type string; |
| description | | description |
| "Name of the VRF"; | | "Name of the VRF"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-PERF-PROCESS-GBL { | | grouping BGP-PERF-PROCESS-GBL { |
| description | | description |
| "BGP PERF PROCESS GBL"; | | "BGP PERF PROCESS GBL"; |
| container ipv4rib-server { | | container ipv4rib-server { |
| description | | description |
| "IPv4 RIB server global info"; | | "IPv4 RIB server global info"; |
| uses BGP-PERF-RIB-GBL-INFO-BAG; | | uses BGP-PERF-RIB-GBL-INFO-BAG; |
| } | | } |
| container ipv6rib-server { | | container ipv6rib-server { |
| description | | description |
| "IPv6 RIB server global info"; | | "IPv6 RIB server global info"; |
| uses BGP-PERF-RIB-GBL-INFO-BAG; | | uses BGP-PERF-RIB-GBL-INFO-BAG; |
| } | | } |
| container te-connection { | | container te-connection { |
| description | | description |
| "MPLS TE server connection info"; | | "MPLS TE server connection info"; |
| uses BGP-PERF-SERVER-CONN-STAT-BAG; | | uses BGP-PERF-SERVER-CONN-STAT-BAG; |
| } | | } |
| container lsd-connection { | | container lsd-connection { |
| description | | description |
| "MPLS LSD server connection info"; | | "MPLS LSD server connection info"; |
| uses BGP-PERF-SERVER-CONN-STAT-BAG; | | uses BGP-PERF-SERVER-CONN-STAT-BAG; |
| } | | } |
| container ds-npl { | | container ds-npl { |
| description | | description |
| "NSR related DS and NPL information"; | | "NSR related DS and NPL information"; |
| uses BGP-PERF-DS-NPL-INFO-BAG; | | uses BGP-PERF-DS-NPL-INFO-BAG; |
| } | | } |
| leaf configuration-items-processed { | | leaf configuration-items-processed { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of config items processed"; | | "Number of config items processed"; |
| } | | } |
| leaf configuration-processing-time { | | leaf configuration-processing-time { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Time spent processing config (milliseconds)"; | | "Time spent processing config (milliseconds)"; |
| } | | } |
| leaf edm-requests-count { | | leaf edm-requests-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of EDM requests processed"; | | "Number of EDM requests processed"; |
| } | | } |
| leaf edm-processing-time { | | leaf edm-processing-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Time spent processing EDM requests (ms)"; | | "Time spent processing EDM requests (ms)"; |
| } | | } |
| leaf brib-api-output-messages-sent { | | leaf brib-api-output-messages-sent { |
| type uint32; | | type uint32; |
| description | | description |
| "bRIB API output messages sent"; | | "bRIB API output messages sent"; |
| } | | } |
| leaf brib-api-output-bytes-sent { | | leaf brib-api-output-bytes-sent { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "bRIB API output bytes sent"; | | "bRIB API output bytes sent"; |
| } | | } |
| leaf brib-api-output-bytes-generated { | | leaf brib-api-output-bytes-generated { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| n | "Number of bytes generated to be sent by the BGP | n | "bRIB API output bytes generated"; |
| RIB API"; | | |
| } | | } |
| leaf brib-api-output-prefixes-advertised { | | leaf brib-api-output-prefixes-advertised { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of prefix advertise messagesto be sent by | n | "bRIB API output prefixes advertised"; |
| the bRIB API"; | | |
| } | | } |
| leaf brib-api-output-prefixes-withdrawn { | | leaf brib-api-output-prefixes-withdrawn { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of prefix withdraw messagesto be sent by | n | "bRIB API output prefixes withdrawn"; |
| the bRIB API"; | | |
| } | | } |
| leaf brib-api-output-sending-time { | | leaf brib-api-output-sending-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Time spent sending output to bRIB API (ms)"; | | "Time spent sending output to bRIB API (ms)"; |
| } | | } |
| leaf brib-api-output-generation-time { | | leaf brib-api-output-generation-time { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Time spent generating output for bRIB API | | "Time spent generating output for bRIB API |
| (milliseconds)"; | | (milliseconds)"; |
| } | | } |
| leaf brib-api-output-calls { | | leaf brib-api-output-calls { |
| type uint32; | | type uint32; |
| description | | description |
| "bRIB API calls to generate output"; | | "bRIB API calls to generate output"; |
| } | | } |
| leaf brib-api-input-messages { | | leaf brib-api-input-messages { |
| type uint32; | | type uint32; |
| description | | description |
| "bRIB API input messages"; | | "bRIB API input messages"; |
| } | | } |
| leaf brib-api-input-bytes { | | leaf brib-api-input-bytes { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "bRIB API input bytes"; | | "bRIB API input bytes"; |
| } | | } |
| leaf brib-api-input-prefixes-received { | | leaf brib-api-input-prefixes-received { |
| type uint32; | | type uint32; |
| description | | description |
| "bRIB API input advertised prefixes received"; | | "bRIB API input advertised prefixes received"; |
| } | | } |
| leaf brib-api-input-withdrawn-prefixes { | | leaf brib-api-input-withdrawn-prefixes { |
| type uint32; | | type uint32; |
| description | | description |
| "bRIB API input withdrawn prefixes received"; | | "bRIB API input withdrawn prefixes received"; |
| } | | } |
| leaf brib-api-input-processing-time { | | leaf brib-api-input-processing-time { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Time spent processing input from bRIB API | | "Time spent processing input from bRIB API |
| (milliseconds)"; | | (milliseconds)"; |
| } | | } |
| leaf instance-node-role { | | leaf instance-node-role { |
| type boolean; | | type boolean; |
| description | | description |
| "Node role - active/passive"; | | "Node role - active/passive"; |
| } | | } |
| leaf active-nsrtcp-phase-two-enter-time { | | leaf active-nsrtcp-phase-two-enter-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time that NSR TCP Init Sync Phase Two entered on | | "Time that NSR TCP Init Sync Phase Two entered on |
| active (seconds since Jan 1 1970)"; | | active (seconds since Jan 1 1970)"; |
| } | | } |
| leaf sec-active-nsrtcp-phase-two-enter-time { | | leaf sec-active-nsrtcp-phase-two-enter-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time that NSR TCP Init Sync Phase Two entered on | | "Time that NSR TCP Init Sync Phase Two entered on |
| active (seconds since Jan 1 1970)"; | | active (seconds since Jan 1 1970)"; |
| } | | } |
| leaf proc-scoped-sync-state { | | leaf proc-scoped-sync-state { |
| type Bgp-scoped-sync-state; | | type Bgp-scoped-sync-state; |
| description | | description |
| n | "Synchronized state of BGP process"; | n | "BGP scoped sync state"; |
| } | | } |
| leaf initial-sync-sessions-added { | | leaf initial-sync-sessions-added { |
| type boolean; | | type boolean; |
| description | | description |
| "If true, BGP has at least one established | | "If true, BGP has at least one established |
| session when NSR initial synchronization is | | session when NSR initial synchronization is |
| started"; | | started"; |
| } | | } |
| leaf in-event-attach-calls { | | leaf in-event-attach-calls { |
| type uint32; | | type uint32; |
| description | | description |
| "event_file_attach calls for input"; | | "event_file_attach calls for input"; |
| } | | } |
| leaf out-event-attach-calls { | | leaf out-event-attach-calls { |
| type uint32; | | type uint32; |
| description | | description |
| "event_file_attach calls for output"; | | "event_file_attach calls for output"; |
| } | | } |
| leaf in-out-event-attach-calls { | | leaf in-out-event-attach-calls { |
| type uint32; | | type uint32; |
| description | | description |
| "event_file_attach calls for input"; | | "event_file_attach calls for input"; |
| } | | } |
| n | leaf updgen-timer-running { | n | leaf updgen-timer-id { |
| type boolean; | | type uint32; |
| description | | description |
| n | "Flag to indicate if update generation master | n | "Updgen master timer ID"; |
| timer is running"; | | |
| } | | } |
| leaf updgen-tree-timer-left { | | leaf updgen-tree-timer-left { |
| type uint64; | | type uint64; |
| description | | description |
| "Time left before the QNX timer would expire"; | | "Time left before the QNX timer would expire"; |
| } | | } |
| leaf updgen-tree-timer-expiry { | | leaf updgen-tree-timer-expiry { |
| type uint64; | | type uint64; |
| description | | description |
| "Time as per tree->mtexptime"; | | "Time as per tree->mtexptime"; |
| } | | } |
| leaf current-clock-time { | | leaf current-clock-time { |
| type uint64; | | type uint64; |
| description | | description |
| "Current time"; | | "Current time"; |
| } | | } |
| leaf updgen-handler-tm { | | leaf updgen-handler-tm { |
| type uint64; | | type uint64; |
| description | | description |
| "Timestamp when updgen timer handler got called"; | | "Timestamp when updgen timer handler got called"; |
| } | | } |
| n | leaf io-timer-running { | n | leaf io-timer-id { |
| type boolean; | | type uint32; |
| description | | description |
| n | "IO master timer Running"; | n | "IO master timer ID"; |
| } | | } |
| leaf io-tree-timer-left { | | leaf io-tree-timer-left { |
| type uint64; | | type uint64; |
| description | | description |
| "Time left before the QNX timer would expire"; | | "Time left before the QNX timer would expire"; |
| } | | } |
| leaf io-tree-timer-expiry { | | leaf io-tree-timer-expiry { |
| type uint64; | | type uint64; |
| description | | description |
| "Time as per tree->mtexptime"; | | "Time as per tree->mtexptime"; |
| } | | } |
| leaf io-handler-tm { | | leaf io-handler-tm { |
| type uint64; | | type uint64; |
| description | | description |
| "Timestamp when IO timer handler got called"; | | "Timestamp when IO timer handler got called"; |
| } | | } |
| leaf qad-messages-sent { | | leaf qad-messages-sent { |
| type uint32; | | type uint32; |
| description | | description |
| "Messages sent on QAD "; | | "Messages sent on QAD "; |
| } | | } |
| leaf qadack-sent { | | leaf qadack-sent { |
| type uint32; | | type uint32; |
| description | | description |
| "Acks sent on QAD "; | | "Acks sent on QAD "; |
| } | | } |
| leaf qad-send-failure { | | leaf qad-send-failure { |
| type uint32; | | type uint32; |
| description | | description |
| "Send failure on QAD "; | | "Send failure on QAD "; |
| } | | } |
| leaf qad-ac-ks-failure { | | leaf qad-ac-ks-failure { |
| type uint32; | | type uint32; |
| description | | description |
| "Ack failure on QAD "; | | "Ack failure on QAD "; |
| } | | } |
| leaf qad-suspends { | | leaf qad-suspends { |
| type uint32; | | type uint32; |
| description | | description |
| "QAD send suspend"; | | "QAD send suspend"; |
| } | | } |
| leaf qad-resumes { | | leaf qad-resumes { |
| type uint32; | | type uint32; |
| description | | description |
| "QAD send resume "; | | "QAD send resume "; |
| } | | } |
| leaf qad-send-drops { | | leaf qad-send-drops { |
| type uint32; | | type uint32; |
| description | | description |
| "Send packets dropped due to null peer "; | | "Send packets dropped due to null peer "; |
| } | | } |
| leaf qad-messages-received { | | leaf qad-messages-received { |
| type uint32; | | type uint32; |
| description | | description |
| "Messages received on QAD "; | | "Messages received on QAD "; |
| } | | } |
| leaf qad-processed { | | leaf qad-processed { |
| type uint32; | | type uint32; |
| description | | description |
| "Messages processed"; | | "Messages processed"; |
| } | | } |
| leaf qad-ac-ks-received { | | leaf qad-ac-ks-received { |
| type uint32; | | type uint32; |
| description | | description |
| "Acks received on QAD "; | | "Acks received on QAD "; |
| } | | } |
| leaf qad-timeout-received { | | leaf qad-timeout-received { |
| type uint32; | | type uint32; |
| description | | description |
| "Timeouts received on QAD "; | | "Timeouts received on QAD "; |
| } | | } |
| leaf qad-init-drops { | | leaf qad-init-drops { |
| type uint32; | | type uint32; |
| description | | description |
| "Packets dropped on standby during initialization"; | | "Packets dropped on standby during initialization"; |
| } | | } |
| leaf qadoos-drops { | | leaf qadoos-drops { |
| type uint32; | | type uint32; |
| description | | description |
| "Packets dropped due to out of sequence | | "Packets dropped due to out of sequence |
| packetreceived"; | | packetreceived"; |
| } | | } |
| leaf qad-recv-drops { | | leaf qad-recv-drops { |
| type uint32; | | type uint32; |
| description | | description |
| "Received packet dropped due to null peer "; | | "Received packet dropped due to null peer "; |
| } | | } |
| leaf qad-timeout-recvd { | | leaf qad-timeout-recvd { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of packet send timeouts "; | | "Number of packet send timeouts "; |
| } | | } |
| leaf nsr-last-reset-reason { | | leaf nsr-last-reset-reason { |
| type uint8; | | type uint8; |
| description | | description |
| "Reason for last nsr state machine reset"; | | "Reason for last nsr state machine reset"; |
| } | | } |
| leaf redcon-nsr-ready { | | leaf redcon-nsr-ready { |
| type boolean; | | type boolean; |
| description | | description |
| "NSR state conveyed to Redcon by bgp - nsr | | "NSR state conveyed to Redcon by bgp - nsr |
| ready/unready"; | | ready/unready"; |
| } | | } |
| leaf redcon-state-time { | | leaf redcon-state-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Time when nsr state wasconveyed to Redcon last"; | | "Time when nsr state wasconveyed to Redcon last"; |
| } | | } |
| leaf active-nsr-state { | | leaf active-nsr-state { |
| type uint32; | | type uint32; |
| description | | description |
| "Current Active BGP nsrstate"; | | "Current Active BGP nsrstate"; |
| } | | } |
| leaf sec-active-nsr-state { | | leaf sec-active-nsr-state { |
| type uint32; | | type uint32; |
| description | | description |
| "Current Sec Active BGP nsrstate"; | | "Current Sec Active BGP nsrstate"; |
| } | | } |
| leaf total-outstanding-postits { | | leaf total-outstanding-postits { |
| type uint32; | | type uint32; |
| description | | description |
| "Total outstanding postits across all neighbors"; | | "Total outstanding postits across all neighbors"; |
| } | | } |
| leaf total-neighbors-with-pending-postits { | | leaf total-neighbors-with-pending-postits { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Count of neighbors with postits pending"; | n | "Total nbrs with pending postits"; |
| } | | } |
| leaf tep2p-auto-tunnel-enabled { | | leaf tep2p-auto-tunnel-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "TE support for P2P auto tunnel"; | | "TE support for P2P auto tunnel"; |
| n | } | n | |
| leaf scoped-sync-batch-count { | | |
| type uint32; | | |
| description | | |
| "Number of scoped sync batch occured"; | | |
| } | | } |
| list active-nsr-mode-enter-time { | | list active-nsr-mode-enter-time { |
| max-elements "26"; | | max-elements "26"; |
| description | | description |
| "Time that each mode was entered (seconds since | | "Time that each mode was entered (seconds since |
| | | |
| Jan 1 1970)"; | | Jan 1 1970)"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time that each mode was entered (seconds since | | "Time that each mode was entered (seconds since |
| | | |
| Jan 1 1970)"; | | Jan 1 1970)"; |
| } | | } |
| } | | } |
| list standby-nsr-mode-enter-time { | | list standby-nsr-mode-enter-time { |
| max-elements "7"; | | max-elements "7"; |
| description | | description |
| "Time that each mode was entered (seconds since | | "Time that each mode was entered (seconds since |
| | | |
| Jan 1 1970)"; | | Jan 1 1970)"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time that each mode was entered (seconds since | | "Time that each mode was entered (seconds since |
| | | |
| Jan 1 1970)"; | | Jan 1 1970)"; |
| } | | } |
| } | | } |
| list active-nsrfo-time { | | list active-nsrfo-time { |
| max-elements "10"; | | max-elements "10"; |
| description | | description |
| "Time that each thread isdone with its | | "Time that each thread isdone with its |
| | | |
| go-activeprocessing (seconds since Jan 1 1970)"; | | go-activeprocessing (seconds since Jan 1 1970)"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time that each thread isdone with its | | "Time that each thread isdone with its |
| | | |
| go-activeprocessing (seconds since Jan 1 1970)"; | | go-activeprocessing (seconds since Jan 1 1970)"; |
| } | | } |
| } | | } |
| list postit-count-info { | | list postit-count-info { |
| description | | description |
| "List of neighbors and their postit counts"; | | "List of neighbors and their postit counts"; |
| uses BGP-POSTIT-COUNT-INFO; | | uses BGP-POSTIT-COUNT-INFO; |
| } | | } |
| list issu-milestone { | | list issu-milestone { |
| description | | description |
| "ISSU Milestones"; | | "ISSU Milestones"; |
| uses BGP-ISSU-MILESTONE-BAG; | | uses BGP-ISSU-MILESTONE-BAG; |
| } | | } |
| n | list receive-stat { | n | |
| description | | |
| "List of Average Receive Stats"; | | |
| uses BGP-NSR-RECV-STATS-INFO; | | |
| } | | |
| } | | } |
| | | |
| grouping BGP-PERF-PROCESS { | | grouping BGP-PERF-PROCESS { |
| description | | description |
| "BGP PERF PROCESS"; | | "BGP PERF PROCESS"; |
| container global { | | container global { |
| description | | description |
| "Global information"; | | "Global information"; |
| uses BGP-PERF-PROCESS-GBL; | | uses BGP-PERF-PROCESS-GBL; |
| } | | } |
| container vrf { | | container vrf { |
| description | | description |
| "VRF information"; | | "VRF information"; |
| uses BGP-PERF-PROCESS-VRF; | | uses BGP-PERF-PROCESS-VRF; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-PROCESS-INFO-VRF { | | grouping BGP-PROCESS-INFO-VRF { |
| description | | description |
| "BGP PROCESS INFO VRF"; | | "BGP PROCESS INFO VRF"; |
| leaf neighbors-count { | | leaf neighbors-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of neighbors"; | | "Number of neighbors"; |
| } | | } |
| leaf established-neighbors-count { | | leaf established-neighbors-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of established neighbors"; | | "Number of established neighbors"; |
| } | | } |
| leaf update-messages-received { | | leaf update-messages-received { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Count of BGP update messages received"; | n | "Number of update messages received"; |
| } | | } |
| leaf update-messages-sent { | | leaf update-messages-sent { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Count of BGP update messages sent"; | n | "No. of update messages sent"; |
| } | | } |
| leaf notifications-received { | | leaf notifications-received { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of BGP notifications received"; | n | "No. of notifications received"; |
| } | | } |
| leaf notifications-sent { | | leaf notifications-sent { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of BGP notifications sent"; | n | "No. of notifications sent"; |
| } | | } |
| leaf network-count { | | leaf network-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of networks"; | | "Number of networks"; |
| } | | } |
| leaf path-count { | | leaf path-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of paths"; | | "Number of paths"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-PROCESS-INFO-GBL { | | grouping BGP-PROCESS-INFO-GBL { |
| description | | description |
| "BGP PROCESS INFO GBL"; | | "BGP PROCESS INFO GBL"; |
| leaf process-instance-node { | | leaf process-instance-node { |
| type string; | | type string; |
| description | | description |
| "Node the process instance is on"; | | "Node the process instance is on"; |
| } | | } |
| leaf restart-count { | | leaf restart-count { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of times BGP has started"; | | "No. of times BGP has started"; |
| } | | } |
| leaf path-attributes-entry-count { | | leaf path-attributes-entry-count { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of path attribute entries"; | | "No. of path attribute entries"; |
| } | | } |
| leaf path-attribute-memory { | | leaf path-attribute-memory { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Memory (bytes) used by path attribute entries"; | | "Memory (bytes) used by path attribute entries"; |
| } | | } |
| leaf as-path-entry-count { | | leaf as-path-entry-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of AS-path entries"; | | "Number of AS-path entries"; |
| } | | } |
| leaf as-path-entries-memory { | | leaf as-path-entries-memory { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Memory (in bytes) used by AS-path entries"; | | "Memory (in bytes) used by AS-path entries"; |
| } | | } |
| leaf community-entry-count { | | leaf community-entry-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of community entries"; | | "Number of community entries"; |
| } | | } |
| leaf community-memory { | | leaf community-memory { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Memory (in bytes) used by community entries"; | | "Memory (in bytes) used by community entries"; |
| } | | } |
| leaf extended-community-entry-count { | | leaf extended-community-entry-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of extended community entries"; | | "Number of extended community entries"; |
| } | | } |
| leaf extended-community-memory { | | leaf extended-community-memory { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Memory (in bytes) used by extended community | | "Memory (in bytes) used by extended community |
| entries"; | | entries"; |
| } | | } |
| leaf pe-distinguisher-label-entry-count { | | leaf pe-distinguisher-label-entry-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of PE distinguisher label entries"; | | "Number of PE distinguisher label entries"; |
| } | | } |
| leaf pe-distinguisher-label-memory { | | leaf pe-distinguisher-label-memory { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Memory (in bytes) used by PE distinguisher | | "Memory (in bytes) used by PE distinguisher |
| labels entries"; | | labels entries"; |
| } | | } |
| leaf pta-entry-count { | | leaf pta-entry-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of PTA entries"; | | "Number of PTA entries"; |
| } | | } |
| leaf pta-memory { | | leaf pta-memory { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Memory (in bytes) used by PTA entries"; | | "Memory (in bytes) used by PTA entries"; |
| } | | } |
| leaf tunnel-encap-entry-count { | | leaf tunnel-encap-entry-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Tunnel encap entries"; | | "Number of Tunnel encap entries"; |
| } | | } |
| leaf tunnel-encap-memory { | | leaf tunnel-encap-memory { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Memory (in bytes) used by tunnel encap entries"; | | "Memory (in bytes) used by tunnel encap entries"; |
| } | | } |
| leaf ribrnh-entry-count { | | leaf ribrnh-entry-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of RIBRNH entries"; | | "Number of RIBRNH entries"; |
| } | | } |
| leaf ribrnh-memory { | | leaf ribrnh-memory { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Memory (in bytes) used by RIBRNH entries"; | | "Memory (in bytes) used by RIBRNH entries"; |
| } | | } |
| leaf ppmp-entry-count { | | leaf ppmp-entry-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of PPMP entries"; | | "Number of PPMP entries"; |
| } | | } |
| leaf ppmp-memory { | | leaf ppmp-memory { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Memory (in bytes) used by PPMP entries"; | | "Memory (in bytes) used by PPMP entries"; |
| } | | } |
| leaf route-reflectors { | | leaf route-reflectors { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of route reflector info entries"; | | "Number of route reflector info entries"; |
| } | | } |
| leaf route-reflector-memory { | | leaf route-reflector-memory { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Memory (in bytes) used by route reflector info | | "Memory (in bytes) used by route reflector info |
| entries"; | | entries"; |
| } | | } |
| leaf nexthop-count { | | leaf nexthop-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of nexthop attribute info entries"; | | "Number of nexthop attribute info entries"; |
| } | | } |
| leaf nexthop-memory { | | leaf nexthop-memory { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Memory (in bytes) used by nexthop attribute info | | "Memory (in bytes) used by nexthop attribute info |
| entries"; | | entries"; |
| } | | } |
| leaf lsattr-entry-count { | | leaf lsattr-entry-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of LASATTR entries"; | | "Number of LASATTR entries"; |
| } | | } |
| leaf lsattr-memory { | | leaf lsattr-memory { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Memory (in bytes) used by LSATTR entries"; | | "Memory (in bytes) used by LSATTR entries"; |
| } | | } |
| leaf attr-set-entry-count { | | leaf attr-set-entry-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of ATTRSET entries"; | | "Number of ATTRSET entries"; |
| } | | } |
| leaf attr-set-memory { | | leaf attr-set-memory { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Memory (in bytes) used by ATTRSET entries"; | | "Memory (in bytes) used by ATTRSET entries"; |
| } | | } |
| leaf prefix-sid-label-index-count { | | leaf prefix-sid-label-index-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Prefix-SID LabelIndex entries"; | | "Number of Prefix-SID LabelIndex entries"; |
| } | | } |
| leaf prefix-sid-label-index-memory { | | leaf prefix-sid-label-index-memory { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Memory (in bytes) used by Prefix-SID LabelIndex | | "Memory (in bytes) used by Prefix-SID LabelIndex |
| entries"; | | entries"; |
| } | | } |
| leaf prefix-sid-orig-srgb-count { | | leaf prefix-sid-orig-srgb-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Prefix-SID OrigSRGB entries"; | | "Number of Prefix-SID OrigSRGB entries"; |
| } | | } |
| leaf prefix-sid-orig-srgb-memory { | | leaf prefix-sid-orig-srgb-memory { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Memory (in bytes) used by Prefix-SID OrigSRGB | | "Memory (in bytes) used by Prefix-SID OrigSRGB |
| entries"; | | entries"; |
| } | | } |
| n | leaf prefix-sid-srv6-layer3-svc-count { | n | leaf prefix-sids-rv6vpnsid-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of Prefix-SID SRv6L3SVC entries"; | n | "Number of Prefix-SID SRv6VPNSID entries"; |
| } | | } |
| n | leaf prefix-sid-srv6-layer3-svc-memory { | n | leaf prefix-sids-rv6vpnsid-memory { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| n | "Memory (in bytes) used by Prefix-SID SRv6L3SVC | n | "Memory (in bytes) used by Prefix-SID SRv6VPNSID |
| entries"; | | |
| } | | |
| leaf prefix-sid-srv6-layer2-svc-count { | | |
| type uint32; | | |
| description | | |
| "Number of Prefix-SID SRv6L2SVC entries"; | | |
| } | | |
| leaf prefix-sid-srv6-layer2-svc-memory { | | |
| type uint32; | | |
| units "byte"; | | |
| description | | |
| "Memory (in bytes) used by Prefix-SID SRv6L2SVC | | |
| entries"; | | entries"; |
| } | | } |
| leaf prefix-sid-unk-tl-vs-count { | | leaf prefix-sid-unk-tl-vs-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Prefix-SID UnkTLVs entries"; | | "Number of Prefix-SID UnkTLVs entries"; |
| } | | } |
| leaf prefix-sid-unk-tl-vs-memory { | | leaf prefix-sid-unk-tl-vs-memory { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Memory (in bytes) used by Prefix-SID UnkTLVs | | "Memory (in bytes) used by Prefix-SID UnkTLVs |
| entries"; | | entries"; |
| } | | } |
| n | leaf oc-rib-attribute-sets-entry-count { | n | |
| type uint32; | | |
| description | | |
| "Number of OC RIB specific attribute-set entries"; | | |
| } | | |
| leaf oc-rib-attribute-set-memory { | | |
| type uint32; | | |
| units "byte"; | | |
| description | | |
| "Memory (in bytes) used by OC RIB attribute-set | | |
| entries"; | | |
| } | | |
| leaf local-as { | | leaf local-as { |
| type uint32; | | type uint32; |
| description | | description |
| "Local autonomous system number"; | | "Local autonomous system number"; |
| } | | } |
| leaf total-vrf-count { | | leaf total-vrf-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Total count of VRFs"; | n | "total vrf count"; |
| } | | } |
| leaf neighbors-count-total { | | leaf neighbors-count-total { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of neighbors"; | | "Total number of neighbors"; |
| } | | } |
| leaf established-neighbors-count-total { | | leaf established-neighbors-count-total { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Total number of neighbors in established state"; | n | "Total umber of established neighbors"; |
| } | | } |
| leaf sn-num-non-dflt-vrf-nbrs { | | leaf sn-num-non-dflt-vrf-nbrs { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of neighbors in all non-default VRFs"; | n | "sn num non dflt vrf nbrs"; |
| } | | } |
| leaf sn-num-non-dflt-vrf-nbrs-estab { | | leaf sn-num-non-dflt-vrf-nbrs-estab { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of established neighbors in all | n | "sn num non dflt vrf nbrs estab"; |
| non-default VRFs"; | | |
| } | | } |
| leaf large-community-entry-count { | | leaf large-community-entry-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of large community entries"; | | "Number of large community entries"; |
| } | | } |
| leaf large-community-memory { | | leaf large-community-memory { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Memory (in bytes) used by large community | | "Memory (in bytes) used by large community |
| entries"; | | entries"; |
| } | | } |
| list pool-size { | | list pool-size { |
| max-elements "15"; | | max-elements "15"; |
| description | | description |
| n | "BGP process maximum pool size"; | n | "pool size"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP process maximum pool size"; | n | "pool size"; |
| } | | } |
| } | | } |
| list pool-alloc-count { | | list pool-alloc-count { |
| max-elements "15"; | | max-elements "15"; |
| description | | description |
| n | "Number of bytes of memory forpool allocation"; | n | "pool alloc count"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| n | units "byte"; | n | |
| description | | description |
| n | "Number of bytes of memory forpool allocation"; | n | "pool alloc count"; |
| } | | } |
| } | | } |
| list pool-free-count { | | list pool-free-count { |
| max-elements "15"; | | max-elements "15"; |
| description | | description |
| n | "Number of bytes of memory freedin pool"; | n | "pool free count"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| n | units "byte"; | n | |
| description | | description |
| n | "Number of bytes of memory freedin pool"; | n | "pool free count"; |
| } | | } |
| } | | } |
| list msg-log-pool-size { | | list msg-log-pool-size { |
| max-elements "5"; | | max-elements "5"; |
| description | | description |
| n | "Number of messages present in pool"; | n | "msg log pool size"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of messages present in pool"; | n | "msg log pool size"; |
| } | | } |
| } | | } |
| list msg-log-pool-alloc-count { | | list msg-log-pool-alloc-count { |
| max-elements "5"; | | max-elements "5"; |
| description | | description |
| n | "Number of messages poolallocation memory"; | n | "msg log pool alloc count"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of messages poolallocation memory"; | n | "msg log pool alloc count"; |
| } | | } |
| } | | } |
| list msg-log-pool-free-count { | | list msg-log-pool-free-count { |
| max-elements "5"; | | max-elements "5"; |
| description | | description |
| n | "Number of messages log freedfrom pool"; | n | "msg log pool free count"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of messages log freedfrom pool"; | n | "msg log pool free count"; |
| } | | } |
| } | | } |
| list bmp-pool-size { | | list bmp-pool-size { |
| max-elements "20"; | | max-elements "20"; |
| description | | description |
| n | "BGP monitoring protocol (BMP) pool size"; | n | "bmp pool size"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP monitoring protocol (BMP) pool size"; | n | "bmp pool size"; |
| } | | } |
| } | | } |
| list bmp-pool-alloc-count { | | list bmp-pool-alloc-count { |
| max-elements "20"; | | max-elements "20"; |
| description | | description |
| n | "Number of bytes of memoryallocated for BGP | n | "bmp pool alloc count"; |
| | | |
| monitoringprotocol pool"; | | |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| n | units "byte"; | n | |
| description | | description |
| n | "Number of bytes of memoryallocated for BGP | n | "bmp pool alloc count"; |
| | | |
| monitoringprotocol pool"; | | |
| } | | } |
| } | | } |
| list bmp-pool-free-count { | | list bmp-pool-free-count { |
| max-elements "20"; | | max-elements "20"; |
| description | | description |
| n | "Number of bytes of memory freedfrom pool"; | n | "bmp pool free count"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| n | units "byte"; | n | |
| description | | description |
| n | "Number of bytes of memory freedfrom pool"; | n | "bmp pool free count"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping BGP-PROCESS-INFO-BAG { | | grouping BGP-PROCESS-INFO-BAG { |
| description | | description |
| "BGP Process information"; | | "BGP Process information"; |
| container global { | | container global { |
| description | | description |
| "Global information"; | | "Global information"; |
| uses BGP-PROCESS-INFO-GBL; | | uses BGP-PROCESS-INFO-GBL; |
| } | | } |
| container vrf { | | container vrf { |
| description | | description |
| "VRF information"; | | "VRF information"; |
| uses BGP-PROCESS-INFO-VRF; | | uses BGP-PROCESS-INFO-VRF; |
| } | | } |
| container performance-statistics { | | container performance-statistics { |
| description | | description |
| n | "BGP process informationperformance statistics"; | n | "Performance statistics"; |
| uses BGP-PERF-PROCESS; | | uses BGP-PERF-PROCESS; |
| } | | } |
| leaf process-instance { | | leaf process-instance { |
| type uint8; | | type uint8; |
| description | | description |
| "ID for the BGP process instance"; | | "ID for the BGP process instance"; |
| } | | } |
| leaf vrf-name { | | leaf vrf-name { |
| type string; | | type string; |
| description | | description |
| "Name of the VRF"; | | "Name of the VRF"; |
| } | | } |
| leaf vrf-totals { | | leaf vrf-totals { |
| type boolean; | | type boolean; |
| description | | description |
| "per VRF counts aggregated across all VRFs"; | | "per VRF counts aggregated across all VRFs"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-BMP-NBR-BAG { | | grouping BGP-BMP-NBR-BAG { |
| description | | description |
| "BMP per Neighbor Details"; | | "BMP per Neighbor Details"; |
| container bmp-neighbor-address { | | container bmp-neighbor-address { |
| description | | description |
| "Address of Nbr that logs to BMP server"; | | "Address of Nbr that logs to BMP server"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| n | leaf vrf-name-xr { | n | |
| type string; | | |
| description | | |
| "Name of the VRF"; | | |
| } | | |
| leaf bmp-neighbor-msg-pending { | | leaf bmp-neighbor-msg-pending { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of messages pending to be sent to BMP | | "Number of messages pending to be sent to BMP |
| Server from this Neighbor"; | | Server from this Neighbor"; |
| } | | } |
| leaf bmp-neighbor-msg-dropped { | | leaf bmp-neighbor-msg-dropped { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of messages dropped sent from this | | "Number of messages dropped sent from this |
| neighbor"; | | neighbor"; |
| } | | } |
| leaf bmp-neighbor-peer-up-sent { | | leaf bmp-neighbor-peer-up-sent { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Peer UP Messages sent from this | | "Number of Peer UP Messages sent from this |
| neighbor"; | | neighbor"; |
| } | | } |
| leaf bmp-neighbor-peer-down-sent { | | leaf bmp-neighbor-peer-down-sent { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Peer DOWN Messages sent from this | | "Number of Peer DOWN Messages sent from this |
| neighbor"; | | neighbor"; |
| } | | } |
| leaf bmp-neighbor-route-monitor-sent { | | leaf bmp-neighbor-route-monitor-sent { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Route Monitor Messages sent"; | | "Number of Route Monitor Messages sent"; |
| } | | } |
| leaf bmp-neighbor-route-monitor-eor-sent { | | leaf bmp-neighbor-route-monitor-eor-sent { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Route Monitor EOR Messages sent"; | | "Number of Route Monitor EOR Messages sent"; |
| } | | } |
| leaf bmp-neighbor-path-update-sent { | | leaf bmp-neighbor-path-update-sent { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Path UpdateMessages sent"; | | "Number of Path UpdateMessages sent"; |
| } | | } |
| leaf bmp-neighbor-path-withdraw-sent { | | leaf bmp-neighbor-path-withdraw-sent { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Path WithdrawMessages sent"; | | "Number of Path WithdrawMessages sent"; |
| } | | } |
| leaf bmp-neighbor-path-update-drop { | | leaf bmp-neighbor-path-update-drop { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of path update drop "; | | "Number of path update drop "; |
| } | | } |
| leaf bmp-neighbor-path-withdraw-drop { | | leaf bmp-neighbor-path-withdraw-drop { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of path wdraw drop "; | | "Number of path wdraw drop "; |
| } | | } |
| leaf bmp-neighbor-upd-msg-sent { | | leaf bmp-neighbor-upd-msg-sent { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of update message sent"; | | "Number of update message sent"; |
| } | | } |
| leaf bmp-neighbor-wdraw-msg-sent { | | leaf bmp-neighbor-wdraw-msg-sent { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of withdraw message sent"; | | "Number of withdraw message sent"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-BMP-SRVR-AFI { | | grouping BGP-BMP-SRVR-AFI { |
| description | | description |
| "BMP AFI Server Details"; | | "BMP AFI Server Details"; |
| container bmp-resume-prefix { | | container bmp-resume-prefix { |
| description | | description |
| "BMP Resume prefix"; | | "BMP Resume prefix"; |
| uses BGP-PREFIXTYPE; | | uses BGP-PREFIXTYPE; |
| } | | } |
| container bmp-filter-neighbor-address { | | container bmp-filter-neighbor-address { |
| description | | description |
| "Filter Neighbor Address"; | | "Filter Neighbor Address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| leaf bmpaf-name { | | leaf bmpaf-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "BMP Address family identifier"; | | "BMP Address family identifier"; |
| } | | } |
| leaf bmp-resume-prefix-len { | | leaf bmp-resume-prefix-len { |
| type uint32; | | type uint32; |
| description | | description |
| "BMP Resume prefix Len"; | | "BMP Resume prefix Len"; |
| } | | } |
| leaf bmp-upd-gen-resume-start-version { | | leaf bmp-upd-gen-resume-start-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Update Gen ResumeWalk start version"; | | "Update Gen ResumeWalk start version"; |
| } | | } |
| leaf bmp-upd-gen-resume-end-version { | | leaf bmp-upd-gen-resume-end-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Update Gen ResumeWalk end version"; | | "Update Gen ResumeWalk end version"; |
| } | | } |
| leaf bmp-upd-gen-walk-stopped { | | leaf bmp-upd-gen-walk-stopped { |
| type boolean; | | type boolean; |
| description | | description |
| "Update Gen WalkStopped"; | | "Update Gen WalkStopped"; |
| } | | } |
| leaf bmp-upd-gen-resume-net-version { | | leaf bmp-upd-gen-resume-net-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Update Gen ResumeWalk Net version"; | | "Update Gen ResumeWalk Net version"; |
| } | | } |
| leaf bmp-upd-gen-walk-run-time-stamp { | | leaf bmp-upd-gen-walk-run-time-stamp { |
| type uint64; | | type uint64; |
| description | | description |
| "Last Update Gen Run time stamp"; | | "Last Update Gen Run time stamp"; |
| } | | } |
| leaf bmp-upd-gen-walk-run-count { | | leaf bmp-upd-gen-walk-run-count { |
| type uint64; | | type uint64; |
| description | | description |
| "Number of times Update Gen ran"; | | "Number of times Update Gen ran"; |
| } | | } |
| leaf bmp-upd-gen-walk-stop-time-stamp { | | leaf bmp-upd-gen-walk-stop-time-stamp { |
| type uint64; | | type uint64; |
| description | | description |
| "Last Update Gen Stop time stamp"; | | "Last Update Gen Stop time stamp"; |
| } | | } |
| leaf bmp-upd-gen-walk-stop-count { | | leaf bmp-upd-gen-walk-stop-count { |
| type uint64; | | type uint64; |
| description | | description |
| "Number of times Update Gen Stopped"; | | "Number of times Update Gen Stopped"; |
| } | | } |
| leaf bmp-init-eor-end-version { | | leaf bmp-init-eor-end-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Version to reach to send EOR"; | | "Version to reach to send EOR"; |
| } | | } |
| leaf bmp-init-eor-pending-cnt { | | leaf bmp-init-eor-pending-cnt { |
| type uint32; | | type uint32; |
| description | | description |
| "Count for pending EOR"; | | "Count for pending EOR"; |
| } | | } |
| leaf bmp-filter-neighbor-address-set { | | leaf bmp-filter-neighbor-address-set { |
| type boolean; | | type boolean; |
| description | | description |
| "Filter Neighbor Address Set ?"; | | "Filter Neighbor Address Set ?"; |
| } | | } |
| leaf bmp-filter-nbr-cnt { | | leaf bmp-filter-nbr-cnt { |
| type uint32; | | type uint32; |
| description | | description |
| "Filter nbr Count for this AFI"; | | "Filter nbr Count for this AFI"; |
| } | | } |
| leaf bmp-send-version { | | leaf bmp-send-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Table Version that this BMP server has caught | | "Table Version that this BMP server has caught |
| upto"; | | upto"; |
| n | } | n | |
| leaf bmp-local-rib-afi-scan-time { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "BMP Local-RIB AFI specific scanner interval in | | |
| seconds"; | | |
| } | | } |
| } | | } |
| | | |
| grouping BGP-BMP-SRVR-BAG { | | grouping BGP-BMP-SRVR-BAG { |
| description | | description |
| "BMP Server Details"; | | "BMP Server Details"; |
| container bmp-server-state-age { | | container bmp-server-state-age { |
| description | | description |
| "Age of current state of BMP Server"; | | "Age of current state of BMP Server"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container bmp-server-state-time-spec { | | container bmp-server-state-time-spec { |
| description | | description |
| "Timespec of current state of BMP Server"; | | "Timespec of current state of BMP Server"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container bmp-server-last-discon-time { | | container bmp-server-last-discon-time { |
| description | | description |
| "Timespec of Last Disconnect event received from | | "Timespec of Last Disconnect event received from |
| BMP server"; | | BMP server"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container update-source-address { | | container update-source-address { |
| description | | description |
| "Address of Interface configured as Update Source"; | | "Address of Interface configured as Update Source"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| leaf bmp-server-id { | | leaf bmp-server-id { |
| type uint8; | | type uint8; |
| description | | description |
| "BMP Server ID"; | | "BMP Server ID"; |
| } | | } |
| leaf bmp-server-host-name { | | leaf bmp-server-host-name { |
| type string; | | type string; |
| description | | description |
| "BMP Server Hostname"; | | "BMP Server Hostname"; |
| } | | } |
| leaf bmp-server-port { | | leaf bmp-server-port { |
| type uint32; | | type uint32; |
| description | | description |
| "BMP Server Port Number"; | | "BMP Server Port Number"; |
| } | | } |
| leaf bmp-server-state { | | leaf bmp-server-state { |
| type Bgp-bmp-state; | | type Bgp-bmp-state; |
| description | | description |
| "Connection state of the BMP server"; | | "Connection state of the BMP server"; |
| } | | } |
| leaf bmp-server-is-flapping { | | leaf bmp-server-is-flapping { |
| type boolean; | | type boolean; |
| description | | description |
| "Connection to the BMP server Flapping"; | | "Connection to the BMP server Flapping"; |
| } | | } |
| leaf bmp-server-nbr-count { | | leaf bmp-server-nbr-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Neighbor count for the BMP Server"; | | "Neighbor count for the BMP Server"; |
| } | | } |
| leaf bmp-init-msg-count { | | leaf bmp-init-msg-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Initiation Msgs sent by this BMP | | "Number of Initiation Msgs sent by this BMP |
| Server"; | | Server"; |
| } | | } |
| leaf bmp-termination-msg-count { | | leaf bmp-termination-msg-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Termination Messages sent by this BMP | | "Number of Termination Messages sent by this BMP |
| Server"; | | Server"; |
| } | | } |
| leaf bmp-status-report-count { | | leaf bmp-status-report-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of Status ReportMessages sent by this BMP | | "Number of Status ReportMessages sent by this BMP |
| Server"; | | Server"; |
| } | | } |
| leaf bmp-per-peer-msg-count { | | leaf bmp-per-peer-msg-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of per peer messages sent"; | | "Total number of per peer messages sent"; |
| } | | } |
| leaf bmp-peer-msg-drop-count { | | leaf bmp-peer-msg-drop-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of messages dropped"; | | "Total number of messages dropped"; |
| } | | } |
| leaf bmp-peer-msg-pending-count { | | leaf bmp-peer-msg-pending-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of bmpQ msgs pending"; | | "Total number of bmpQ msgs pending"; |
| } | | } |
| leaf tos-type { | | leaf tos-type { |
| type uint8; | | type uint8; |
| description | | description |
| "Precedence (0) or DSCP (1) type"; | | "Precedence (0) or DSCP (1) type"; |
| } | | } |
| leaf tos-value { | | leaf tos-value { |
| type uint8; | | type uint8; |
| description | | description |
| "Precedence or DSCP value"; | | "Precedence or DSCP value"; |
| } | | } |
| leaf update-source-interface-name { | | leaf update-source-interface-name { |
| type string; | | type string; |
| description | | description |
| "Interface configured as Update Source"; | | "Interface configured as Update Source"; |
| } | | } |
| leaf update-source-vrf-id { | | leaf update-source-vrf-id { |
| type uint32; | | type uint32; |
| description | | description |
| "VRF ID of interface configured as Update Source"; | | "VRF ID of interface configured as Update Source"; |
| } | | } |
| leaf bmp-vrf-name { | | leaf bmp-vrf-name { |
| type string; | | type string; |
| description | | description |
| "VRF Name configured"; | | "VRF Name configured"; |
| } | | } |
| leaf bmp-vrf-id { | | leaf bmp-vrf-id { |
| type uint32; | | type uint32; |
| description | | description |
| "VRF ID for the vrf name configured"; | | "VRF ID for the vrf name configured"; |
| } | | } |
| leaf bmp-update-mode { | | leaf bmp-update-mode { |
| type Bgp-bmp-upd-mode; | | type Bgp-bmp-upd-mode; |
| description | | description |
| "Update sending mode configured for this BMP | | "Update sending mode configured for this BMP |
| n | server. This field is deprecated"; | n | server"; |
| } | | |
| leaf bmp-update-modes-bitmap { | | |
| type uint32; | | |
| description | | |
| "Bitmap with bits corresponding toUpdate sending | | |
| modes configured"; | | |
| } | | } |
| leaf tcp-keep-alive-interval { | | leaf tcp-keep-alive-interval { |
| type uint32; | | type uint32; |
| description | | description |
| "TCP Keep alive interval configured"; | | "TCP Keep alive interval configured"; |
| } | | } |
| leaf tcp-maximum-segment-size { | | leaf tcp-maximum-segment-size { |
| type uint32; | | type uint32; |
| description | | description |
| "TCP Maximum Segments size configured"; | | "TCP Maximum Segments size configured"; |
| } | | } |
| leaf tcp-write-cb-pending { | | leaf tcp-write-cb-pending { |
| type uint32; | | type uint32; |
| description | | description |
| "Are we waiting for TCP write callback ?"; | | "Are we waiting for TCP write callback ?"; |
| } | | } |
| leaf tcp-last-write-result { | | leaf tcp-last-write-result { |
| type uint32; | | type uint32; |
| description | | description |
| "Last TCP Socket write status"; | | "Last TCP Socket write status"; |
| } | | } |
| leaf tcp-last-write-cb-time { | | leaf tcp-last-write-cb-time { |
| type uint64; | | type uint64; |
| description | | description |
| "Last TCP Write CB time"; | | "Last TCP Write CB time"; |
| } | | } |
| leaf tcp-last-write-time { | | leaf tcp-last-write-time { |
| type uint64; | | type uint64; |
| description | | description |
| "Last TCP Write time"; | | "Last TCP Write time"; |
| } | | } |
| leaf bmpq-last-write-pulse-sent-time { | | leaf bmpq-last-write-pulse-sent-time { |
| type uint64; | | type uint64; |
| description | | description |
| "Last BMPQ write pulse Sent time"; | | "Last BMPQ write pulse Sent time"; |
| } | | } |
| leaf bmpq-last-all-write-pulse-sent-time { | | leaf bmpq-last-all-write-pulse-sent-time { |
| type uint64; | | type uint64; |
| description | | description |
| "Last BMPQ write pulse Sent for all BMP servers "; | | "Last BMPQ write pulse Sent for all BMP servers "; |
| } | | } |
| leaf bmpq-last-write-pulse-cb-time { | | leaf bmpq-last-write-pulse-cb-time { |
| type uint64; | | type uint64; |
| description | | description |
| "Last BMPQ write pulse callback time"; | | "Last BMPQ write pulse callback time"; |
| } | | } |
| leaf path-update-count { | | leaf path-update-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of path update sent "; | | "Number of path update sent "; |
| } | | } |
| leaf path-withdraw-count { | | leaf path-withdraw-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of path wdraw sent"; | | "Number of path wdraw sent"; |
| } | | } |
| leaf path-update-drop { | | leaf path-update-drop { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of path update drop "; | | "Number of path update drop "; |
| } | | } |
| leaf path-withdraw-drop { | | leaf path-withdraw-drop { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of path wdraw drop "; | | "Number of path wdraw drop "; |
| } | | } |
| leaf bmp-peer-msg-pending-count-max { | | leaf bmp-peer-msg-pending-count-max { |
| type uint32; | | type uint32; |
| description | | description |
| "Total bmpQ msgs pending max"; | | "Total bmpQ msgs pending max"; |
| } | | } |
| leaf bmp-peer-msg-pending-count-hwts { | | leaf bmp-peer-msg-pending-count-hwts { |
| type uint64; | | type uint64; |
| description | | description |
| "Total bmpQ msgs pending max time"; | | "Total bmpQ msgs pending max time"; |
| } | | } |
| leaf bmp-bytes-written-tcp { | | leaf bmp-bytes-written-tcp { |
| type uint64; | | type uint64; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Total bytes sent to TCP"; | | "Total bytes sent to TCP"; |
| } | | } |
| leaf tcp-write-time { | | leaf tcp-write-time { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Time spent processing sending msg to | | "Time spent processing sending msg to |
| TCP(milliseconds)"; | | TCP(milliseconds)"; |
| } | | } |
| leaf bmpr-mon-upd-messages { | | leaf bmpr-mon-upd-messages { |
| type uint32; | | type uint32; |
| description | | description |
| "Total bmpQ update msgs "; | | "Total bmpQ update msgs "; |
| } | | } |
| leaf bmpr-mon-wdraw-messages { | | leaf bmpr-mon-wdraw-messages { |
| type uint32; | | type uint32; |
| description | | description |
| "Total bmpQ withdraw msgs "; | | "Total bmpQ withdraw msgs "; |
| } | | } |
| leaf bmp-messages-wdraw-discarded { | | leaf bmp-messages-wdraw-discarded { |
| type uint32; | | type uint32; |
| description | | description |
| "Total bmpQ wdraw msgs discarded because of peer | | "Total bmpQ wdraw msgs discarded because of peer |
| down"; | | down"; |
| } | | } |
| leaf bmp-pfx-wdraw-discarded { | | leaf bmp-pfx-wdraw-discarded { |
| type uint32; | | type uint32; |
| description | | description |
| "Total bmpQ wdraw pfxes discarded because of peer | | "Total bmpQ wdraw pfxes discarded because of peer |
| down"; | | down"; |
| } | | } |
| leaf bmp-per-peer-msg-route-mon-count { | | leaf bmp-per-peer-msg-route-mon-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of per peer route mon messages sent"; | | "Total number of per peer route mon messages sent"; |
| } | | } |
| leaf bmpr-mon-update-gen-time { | | leaf bmpr-mon-update-gen-time { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Time spent in update generation(milliseconds)"; | | "Time spent in update generation(milliseconds)"; |
| } | | } |
| leaf bmpr-mon-eo-rmessages { | | leaf bmpr-mon-eo-rmessages { |
| type uint32; | | type uint32; |
| description | | description |
| "Total bmpQ EOR update msgs "; | | "Total bmpQ EOR update msgs "; |
| } | | } |
| leaf bmp-rmon-cur-buffer-size { | | leaf bmp-rmon-cur-buffer-size { |
| type uint64; | | type uint64; |
| description | | description |
| "Current Buffer usage per BMP Route Mon"; | | "Current Buffer usage per BMP Route Mon"; |
| } | | } |
| leaf bmp-maximum-buffer-size-route-mon { | | leaf bmp-maximum-buffer-size-route-mon { |
| type uint64; | | type uint64; |
| description | | description |
| "Buffer limit used for route mon"; | | "Buffer limit used for route mon"; |
| } | | } |
| leaf bmp-server-up-count { | | leaf bmp-server-up-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of BMP server that are UP"; | | "Number of BMP server that are UP"; |
| } | | } |
| leaf bmp-upd-gen-in-progress { | | leaf bmp-upd-gen-in-progress { |
| type boolean; | | type boolean; |
| description | | description |
| "Update generation in progress"; | | "Update generation in progress"; |
| } | | } |
| leaf bmp-reset-walk-in-progress { | | leaf bmp-reset-walk-in-progress { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if BGP monitoring protocol | n | |
| server reset walk is in progress"; | | "Reset walk in progress"; |
| } | | |
| leaf bmp-in-post-pol-advertisement-interval-sec { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "BMP Inbound Post-Policy advertisement interval | | |
| seconds"; | | |
| } | | |
| leaf bmp-in-post-pol-advertisement-interval-msec { | | |
| type uint32; | | |
| units "millisecond"; | | |
| description | | |
| "BMP Inbound Post-Policy advertisement interval | | |
| milliseconds"; | | |
| } | | |
| leaf bmp-in-post-pol-scan-time { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "BMP scanner interval in seconds"; | | |
| } | | |
| leaf bmp-local-rib-advertisement-interval-sec { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "BMP Local-RIB advertisement interval seconds"; | | |
| } | | |
| leaf bmp-local-rib-advertisement-interval-msec { | | |
| type uint32; | | |
| units "millisecond"; | | |
| description | | |
| "BMP Local-RIB advertisement interval | | |
| milliseconds"; | | |
| } | | |
| leaf bmp-local-rib-scan-time { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "BMP Local-RIB scanner interval in seconds"; | | |
| } | | |
| leaf bmp-flapping-delay { | | |
| type uint16; | | |
| units "second"; | | |
| description | | |
| "BMP Flapping Delay in seconds"; | | |
| } | | |
| leaf bmp-initial-delay { | | |
| type uint16; | | |
| units "second"; | | |
| description | | |
| "BMP Initial Delay in seconds"; | | |
| } | | |
| leaf bmp-initial-refresh-delay { | | |
| type uint16; | | |
| units "second"; | | |
| description | | |
| "BMP Initial Refresh Delay in seconds"; | | |
| } | | |
| leaf bmp-initial-refresh-spread { | | |
| type uint16; | | |
| units "second"; | | |
| description | | |
| "BMP Initial Refresh Spread in seconds"; | | |
| } | | |
| leaf bmp-stats-reporting-time-delay { | | |
| type uint16; | | |
| units "second"; | | |
| description | | |
| "BMP Stats Reporting Time in seconds"; | | |
| } | | } |
| list bmpafi-info { | | list bmpafi-info { |
| description | | description |
| "AFI specific info for BMP server"; | | "AFI specific info for BMP server"; |
| uses BGP-BMP-SRVR-AFI; | | uses BGP-BMP-SRVR-AFI; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPDFILTER-ELEM-BAG { | | grouping BGP-UPDFILTER-ELEM-BAG { |
| description | | description |
| "BGP Update filtering element information"; | | "BGP Update filtering element information"; |
| leaf update-attribute-flags { | | leaf update-attribute-flags { |
| type uint8; | | type uint8; |
| description | | description |
| "Attribute Flags [RFC4271: BGP4]"; | | "Attribute Flags [RFC4271: BGP4]"; |
| } | | } |
| leaf update-attribute-code { | | leaf update-attribute-code { |
| type uint8; | | type uint8; |
| description | | description |
| "Attribute code [RFC4271: BGP4]"; | | "Attribute code [RFC4271: BGP4]"; |
| } | | } |
| leaf update-filter-action { | | leaf update-filter-action { |
| type Bgp-bag-upd-filter-action; | | type Bgp-bag-upd-filter-action; |
| description | | description |
| "Filtering action"; | | "Filtering action"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPDFILTER-MSG-BAG { | | grouping BGP-UPDFILTER-MSG-BAG { |
| description | | description |
| "BGP Update filter message information"; | | "BGP Update filter message information"; |
| container update-filter-message-timestamp { | | container update-filter-message-timestamp { |
| description | | description |
| "Message timestamp: time elapsed since 00:00:00 | | "Message timestamp: time elapsed since 00:00:00 |
| UTC, January 1, 1970"; | | UTC, January 1, 1970"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| leaf update-filtered-attribute-count { | | leaf update-filtered-attribute-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Total number of attributes filtered in | n | "Filtered attributes count"; |
| thismessage"; | | |
| } | | } |
| leaf update-filter-final-action { | | leaf update-filter-final-action { |
| type Bgp-bag-upd-filter-action; | | type Bgp-bag-upd-filter-action; |
| description | | description |
| "Filtering final action"; | | "Filtering final action"; |
| } | | } |
| leaf update-filter-nlri-address-family { | | leaf update-filter-nlri-address-family { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "NLRI address-family"; | | "NLRI address-family"; |
| } | | } |
| leaf update-filter-nlri-string { | | leaf update-filter-nlri-string { |
| type string; | | type string; |
| description | | description |
| "List of NLRIs in string format"; | | "List of NLRIs in string format"; |
| } | | } |
| leaf update-filter-nlri-string-truncated { | | leaf update-filter-nlri-string-truncated { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates whether NLRI string was truncated due | | "Indicates whether NLRI string was truncated due |
| to lack of space"; | | to lack of space"; |
| } | | } |
| list update-filter-message-data { | | list update-filter-message-data { |
| description | | description |
| "Raw Message data in binary format"; | | "Raw Message data in binary format"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "Raw Message data in binary format"; | | "Raw Message data in binary format"; |
| } | | } |
| } | | } |
| list update-filter-element { | | list update-filter-element { |
| max-elements "3"; | | max-elements "3"; |
| description | | description |
| "Filtering element list"; | | "Filtering element list"; |
| uses BGP-UPDFILTER-ELEM-BAG; | | uses BGP-UPDFILTER-ELEM-BAG; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPDFILTER-ATTRF-ATTR-BAG { | | grouping BGP-UPDFILTER-ATTRF-ATTR-BAG { |
| description | | description |
| "BGP Update filtering attributes information"; | | "BGP Update filtering attributes information"; |
| container last-update-filter-match-timestamp { | | container last-update-filter-match-timestamp { |
| description | | description |
| "Last attribute filtered time: time elapsed since | | "Last attribute filtered time: time elapsed since |
| 00:00:00 UTC, January 1, 1970"; | | 00:00:00 UTC, January 1, 1970"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| leaf update-internal-attribute-code { | | leaf update-internal-attribute-code { |
| type uint32; | | type uint32; |
| description | | description |
| "Internal attribute code [RFC4271: BGP4]"; | | "Internal attribute code [RFC4271: BGP4]"; |
| } | | } |
| leaf update-filter-action { | | leaf update-filter-action { |
| type Bgp-bag-upd-filter-action; | | type Bgp-bag-upd-filter-action; |
| description | | description |
| "Filtering action"; | | "Filtering action"; |
| } | | } |
| leaf update-filter-match-count { | | leaf update-filter-match-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Filter match counter"; | | "Filter match counter"; |
| } | | } |
| leaf establishment-update-filter-match-count { | | leaf establishment-update-filter-match-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Filter match counter since last session | | "Filter match counter since last session |
| establishment"; | | establishment"; |
| } | | } |
| leaf last-update-filter-match-age { | | leaf last-update-filter-match-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since this attribute was last filtered (in | | "Time since this attribute was last filtered (in |
| seconds)"; | | seconds)"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPDFILTER-NBR-BAG { | | grouping BGP-UPDFILTER-NBR-BAG { |
| description | | description |
| "BGP Update filtering Neighbor information"; | | "BGP Update filtering Neighbor information"; |
| container update-neighbor-address { | | container update-neighbor-address { |
| description | | description |
| "Neighbor address"; | | "Neighbor address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container first-update-filtered-timestamp { | | container first-update-filtered-timestamp { |
| description | | description |
| "First filtered message received time: time | | "First filtered message received time: time |
| elapsed since 00:00:00 UTC, January 1, 1970"; | | elapsed since 00:00:00 UTC, January 1, 1970"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-update-filtered-timestamp { | | container last-update-filtered-timestamp { |
| description | | description |
| "Last filtered message received time: time | | "Last filtered message received time: time |
| elapsed since 00:00:00 UTC, January 1, 1970"; | | elapsed since 00:00:00 UTC, January 1, 1970"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| leaf update-vrf-name { | | leaf update-vrf-name { |
| type string; | | type string; |
| description | | description |
| "VRF Name"; | | "VRF Name"; |
| } | | } |
| leaf update-filter-logging-enabled { | | leaf update-filter-logging-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Logging is enabled"; | | "Logging is enabled"; |
| } | | } |
| leaf configured-update-filter-message-buffer-count { | | leaf configured-update-filter-message-buffer-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Total number of configured update filter | n | "Configured Filtered message buffer count"; |
| messagebuffer size"; | | |
| } | | } |
| leaf operational-update-filter-message-buffer-count { | | leaf operational-update-filter-message-buffer-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of messages in the message buffer"; | n | "Operational Filtered messages buffer count"; |
| } | | } |
| leaf update-filter-message-buffer-circular { | | leaf update-filter-message-buffer-circular { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates if the message buffers are circular"; | | "Indicates if the message buffers are circular"; |
| } | | } |
| leaf update-attribute-filter-group-name { | | leaf update-attribute-filter-group-name { |
| type string; | | type string; |
| description | | description |
| n | "String format BGP attribute-filter group name"; | n | "Update attribute-filter group name"; |
| } | | } |
| leaf operational-update-attribute-filtering-enabled { | | leaf operational-update-attribute-filtering-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Attribute filtering is enabled"; | | "Attribute filtering is enabled"; |
| } | | } |
| leaf message-update-attribute-filtering-enabled { | | leaf message-update-attribute-filtering-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Attribute filtering is enabled for the current | | "Attribute filtering is enabled for the current |
| message being parsed"; | | message being parsed"; |
| } | | } |
| leaf total-filter-update-message-count { | | leaf total-filter-update-message-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Total number of filtered messages encoutered"; | n | "Total update messages count"; |
| } | | } |
| leaf establishment-total-filter-update-message-count { | | leaf establishment-total-filter-update-message-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Total update messages count since session | | "Total update messages count since session |
| establishment"; | | establishment"; |
| } | | } |
| leaf update-filtered-message-count { | | leaf update-filtered-message-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Total number of filtered messages encountered so | n | "Filtered messages count"; |
| far"; | | |
| } | | } |
| leaf establishment-update-filtered-message-count { | | leaf establishment-update-filtered-message-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Filtered messages count since session | | "Filtered messages count since session |
| establishment"; | | establishment"; |
| } | | } |
| leaf last-update-filtered-age { | | leaf last-update-filtered-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last filtered message received event | | "Time since last filtered message received event |
| (in seconds)"; | | (in seconds)"; |
| } | | } |
| leaf update-filter-message-list-count { | | leaf update-filter-message-list-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Filtered messages list count"; | | "Filtered messages list count"; |
| } | | } |
| list update-attribute-filter-attributes { | | list update-attribute-filter-attributes { |
| description | | description |
| "List of attributes that can be filtered"; | | "List of attributes that can be filtered"; |
| uses BGP-UPDFILTER-ATTRF-ATTR-BAG; | | uses BGP-UPDFILTER-ATTRF-ATTR-BAG; |
| } | | } |
| list update-filter-message { | | list update-filter-message { |
| description | | description |
| "List of filtered messages"; | | "List of filtered messages"; |
| uses BGP-UPDFILTER-MSG-BAG; | | uses BGP-UPDFILTER-MSG-BAG; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPDERR-ELEM-BAG { | | grouping BGP-UPDERR-ELEM-BAG { |
| description | | description |
| "BGP Update error-handling element information"; | | "BGP Update error-handling element information"; |
| leaf update-attribute-flags { | | leaf update-attribute-flags { |
| type uint8; | | type uint8; |
| description | | description |
| "Attribute Flags [RFC4271: BGP4]"; | | "Attribute Flags [RFC4271: BGP4]"; |
| } | | } |
| leaf update-attribute-code { | | leaf update-attribute-code { |
| type uint8; | | type uint8; |
| description | | description |
| "Attribute code [RFC4271: BGP4]"; | | "Attribute code [RFC4271: BGP4]"; |
| } | | } |
| leaf update-attribute-length { | | leaf update-attribute-length { |
| type uint16; | | type uint16; |
| description | | description |
| "Attribute Length [RFC4271: BGP4]"; | | "Attribute Length [RFC4271: BGP4]"; |
| } | | } |
| leaf update-error-data { | | leaf update-error-data { |
| type yang:hex-string; | | type yang:hex-string; |
| description | | description |
| "Error data"; | | "Error data"; |
| } | | } |
| leaf update-error-data-length { | | leaf update-error-data-length { |
| type uint16; | | type uint16; |
| description | | description |
| "Error data length"; | | "Error data length"; |
| } | | } |
| leaf update-error-action { | | leaf update-error-action { |
| type Bgp-bag-upd-err-action; | | type Bgp-bag-upd-err-action; |
| description | | description |
| "Error action"; | | "Error action"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPDERR-RESET-DATA-BAG { | | grouping BGP-UPDERR-RESET-DATA-BAG { |
| description | | description |
| "BGP Update error-handling session reset | | "BGP Update error-handling session reset |
| information"; | | information"; |
| leaf update-error-reset-reason { | | leaf update-error-reset-reason { |
| type Bgp-reset-reason-index; | | type Bgp-reset-reason-index; |
| description | | description |
| "Reset Reason"; | | "Reset Reason"; |
| } | | } |
| leaf update-error-reset-notification-code { | | leaf update-error-reset-notification-code { |
| type uint8; | | type uint8; |
| description | | description |
| "Notification code"; | | "Notification code"; |
| } | | } |
| leaf update-error-reset-notification-sub-code { | | leaf update-error-reset-notification-sub-code { |
| type uint16; | | type uint16; |
| description | | description |
| "Notification sub code"; | | "Notification sub code"; |
| } | | } |
| leaf update-error-reset-notification-data { | | leaf update-error-reset-notification-data { |
| type yang:hex-string; | | type yang:hex-string; |
| description | | description |
| "Notification data"; | | "Notification data"; |
| } | | } |
| leaf update-error-reset-notification-data-length { | | leaf update-error-reset-notification-data-length { |
| type uint16; | | type uint16; |
| description | | description |
| "Notification data length"; | | "Notification data length"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPDERR-MSG-BAG { | | grouping BGP-UPDERR-MSG-BAG { |
| description | | description |
| "BGP Update error message information"; | | "BGP Update error message information"; |
| container update-message-timestamp { | | container update-message-timestamp { |
| description | | description |
| "Message timestamp: time elapsed since 00:00:00 | | "Message timestamp: time elapsed since 00:00:00 |
| UTC, January 1, 1970"; | | UTC, January 1, 1970"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container update-message-reset-data { | | container update-message-reset-data { |
| description | | description |
| "Reset data"; | | "Reset data"; |
| uses BGP-UPDERR-RESET-DATA-BAG; | | uses BGP-UPDERR-RESET-DATA-BAG; |
| } | | } |
| leaf update-error-final-action { | | leaf update-error-final-action { |
| type Bgp-bag-upd-err-action; | | type Bgp-bag-upd-err-action; |
| description | | description |
| "Error final action"; | | "Error final action"; |
| } | | } |
| leaf update-attribute-discard-count { | | leaf update-attribute-discard-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Discarded attribute count"; | | "Discarded attribute count"; |
| } | | } |
| leaf update-error-nlri-address-family { | | leaf update-error-nlri-address-family { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "NLRI address-family"; | | "NLRI address-family"; |
| } | | } |
| leaf update-error-nlri-string { | | leaf update-error-nlri-string { |
| type string; | | type string; |
| description | | description |
| "List of NLRIs in string format"; | | "List of NLRIs in string format"; |
| } | | } |
| leaf update-error-nlri-string-truncated { | | leaf update-error-nlri-string-truncated { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates whether NLRI string was truncated due | | "Indicates whether NLRI string was truncated due |
| to lack of space"; | | to lack of space"; |
| } | | } |
| list update-message-data { | | list update-message-data { |
| description | | description |
| "Raw Message data in binary format"; | | "Raw Message data in binary format"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "Raw Message data in binary format"; | | "Raw Message data in binary format"; |
| } | | } |
| } | | } |
| list update-error-element { | | list update-error-element { |
| max-elements "3"; | | max-elements "3"; |
| description | | description |
| "Error element list"; | | "Error element list"; |
| uses BGP-UPDERR-ELEM-BAG; | | uses BGP-UPDERR-ELEM-BAG; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPDERR-NBR-BAG { | | grouping BGP-UPDERR-NBR-BAG { |
| description | | description |
| "BGP Update error-handling Neighbor information"; | | "BGP Update error-handling Neighbor information"; |
| container update-neighbor-address { | | container update-neighbor-address { |
| description | | description |
| "Neighbor address"; | | "Neighbor address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container first-update-malformed-timestamp { | | container first-update-malformed-timestamp { |
| description | | description |
| "First malformed message received time: time | | "First malformed message received time: time |
| elapsed since 00:00:00 UTC, January 1, 1970"; | | elapsed since 00:00:00 UTC, January 1, 1970"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-update-malformed-timestamp { | | container last-update-malformed-timestamp { |
| description | | description |
| "Last malformed message received time: time | | "Last malformed message received time: time |
| elapsed since 00:00:00 UTC, January 1, 1970"; | | elapsed since 00:00:00 UTC, January 1, 1970"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container first-update-memory-allocation-fail-timestamp { | | container first-update-memory-allocation-fail-timestamp { |
| description | | description |
| "First memory allocation failure time: time | | "First memory allocation failure time: time |
| elapsed since 00:00:00 UTC, January 1, 1970"; | | elapsed since 00:00:00 UTC, January 1, 1970"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-update-memory-allocation-fail-timestamp { | | container last-update-memory-allocation-fail-timestamp { |
| description | | description |
| "Last memory allocation failure time: time | | "Last memory allocation failure time: time |
| elapsed since 00:00:00 UTC, January 1, 1970"; | | elapsed since 00:00:00 UTC, January 1, 1970"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container first-update-error-handling-reset-timestamp { | | container first-update-error-handling-reset-timestamp { |
| description | | description |
| "First error-handling reset time: time elapsed | | "First error-handling reset time: time elapsed |
| since 00:00:00 UTC, January 1, 1970"; | | since 00:00:00 UTC, January 1, 1970"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-error-handling-reset-timestamp { | | container last-error-handling-reset-timestamp { |
| description | | description |
| "Last error-handling reset time: time elapsed | | "Last error-handling reset time: time elapsed |
| since 00:00:00 UTC, January 1, 1970"; | | since 00:00:00 UTC, January 1, 1970"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| leaf update-vrf-name { | | leaf update-vrf-name { |
| type string; | | type string; |
| description | | description |
| "VRF Name"; | | "VRF Name"; |
| } | | } |
| leaf update-error-handling-avoid-reset { | | leaf update-error-handling-avoid-reset { |
| type boolean; | | type boolean; |
| description | | description |
| "Configure error-handling to avoid resets"; | | "Configure error-handling to avoid resets"; |
| } | | } |
| leaf total-update-message-count { | | leaf total-update-message-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "The total number of update messages encoutered | n | "Total update messages count"; |
| so far"; | | |
| } | | } |
| leaf update-malformed-message-count { | | leaf update-malformed-message-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "The toatl number of malform update messages so | n | "Malformed messages count"; |
| far"; | | |
| } | | } |
| leaf last-update-malformed-age { | | leaf last-update-malformed-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last malformed message received event | | "Time since last malformed message received event |
| (in seconds)"; | | (in seconds)"; |
| } | | } |
| leaf update-memory-allocation-fail-count { | | leaf update-memory-allocation-fail-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Total number of memory allocation failures"; | n | "Memory allocation failure count"; |
| } | | } |
| leaf last-update-memory-allocation-fail-age { | | leaf last-update-memory-allocation-fail-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last memory allocation failure event | | "Time since last memory allocation failure event |
| (in seconds)"; | | (in seconds)"; |
| } | | } |
| leaf update-error-handling-reset-count { | | leaf update-error-handling-reset-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Total number of neighbor reset due to | n | "Error-handling reset count"; |
| error-handling"; | | |
| } | | } |
| leaf last-error-handling-reset-age { | | leaf last-error-handling-reset-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last error-handling reset event (in | | "Time since last error-handling reset event (in |
| seconds)"; | | seconds)"; |
| } | | } |
| leaf update-error-message-list-count { | | leaf update-error-message-list-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Malformed messages list count"; | | "Malformed messages list count"; |
| } | | } |
| leaf update-attribute-discard-count { | | leaf update-attribute-discard-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Discarded attribute count"; | | "Discarded attribute count"; |
| } | | } |
| leaf establishment-total-update-message-count { | | leaf establishment-total-update-message-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Total update messages count since session | | "Total update messages count since session |
| establishment"; | | establishment"; |
| n | } | n | |
| leaf update-error-handling-treat-as-withdraw { | | |
| type boolean; | | |
| description | | |
| "Error-handling set to treat as withdraw"; | | |
| } | | } |
| list establishment-action-count { | | list establishment-action-count { |
| max-elements "7"; | | max-elements "7"; |
| description | | description |
| "Number of occurence of each action type since | | "Number of occurence of each action type since |
| | | |
| session establishment"; | | session establishment"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of occurence of each action type since | | "Number of occurence of each action type since |
| | | |
| session establishment"; | | session establishment"; |
| } | | } |
| } | | } |
| list update-error-message { | | list update-error-message { |
| description | | description |
| "List of malformed messages"; | | "List of malformed messages"; |
| uses BGP-UPDERR-MSG-BAG; | | uses BGP-UPDERR-MSG-BAG; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-GLOBAL-PROCESS-INFO-VRF { | | grouping BGP-GLOBAL-PROCESS-INFO-VRF { |
| description | | description |
| "BGP GLOBAL PROCESS INFO VRF"; | | "BGP GLOBAL PROCESS INFO VRF"; |
| leaf vrf-is-active { | | leaf vrf-is-active { |
| type boolean; | | type boolean; |
| description | | description |
| "VRF state"; | | "VRF state"; |
| } | | } |
| leaf route-distinguisher { | | leaf route-distinguisher { |
| type yang:hex-string; | | type yang:hex-string; |
| description | | description |
| n | "BGP global process route distinguisher"; | n | "Route Distinguisher"; |
| } | | } |
| leaf router-id { | | leaf router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Router ID for the VRF"; | | "Router ID for the VRF"; |
| } | | } |
| leaf configured-router-id { | | leaf configured-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| n | "BGP global process configured router ID"; | n | "Configured router ID"; |
| } | | } |
| leaf is-redistribute-ibgp-to-ig-ps-enabled { | | leaf is-redistribute-ibgp-to-ig-ps-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Redistribute iBGP into IGPs enabled"; | | "Redistribute iBGP into IGPs enabled"; |
| } | | } |
| leaf is-fast-external-fallover-enabled { | | leaf is-fast-external-fallover-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if fast external fallover is | n | "Fast external fallover enabled"; |
| enabled"; | | |
| } | | } |
| leaf is-bestpath-missing-med-is-worst-enabled { | | leaf is-bestpath-missing-med-is-worst-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Bestpath: Treat missing MED as worst"; | | "Bestpath: Treat missing MED as worst"; |
| } | | } |
| leaf is-bestpath-always-compare-med-enabled { | | leaf is-bestpath-always-compare-med-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Bestpath: Always compare MED"; | | "Bestpath: Always compare MED"; |
| } | | } |
| leaf is-bestpath-ignore-as-path-enabled { | | leaf is-bestpath-ignore-as-path-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Bestpath: Ignore AS path"; | | "Bestpath: Ignore AS path"; |
| } | | } |
| leaf is-bestpath-as-path-mpath-relax-enabled { | | leaf is-bestpath-as-path-mpath-relax-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Bestpath: Relax AS path for mpath"; | | "Bestpath: Relax AS path for mpath"; |
| } | | } |
| leaf is-bestpath-compare-med-from-confed-peer-enabled { | | leaf is-bestpath-compare-med-from-confed-peer-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Bestpath: Compare MED from confed peer"; | | "Bestpath: Compare MED from confed peer"; |
| } | | } |
| leaf is-bestpath-compare-router-id-for-ebgp-peers-enabled { | | leaf is-bestpath-compare-router-id-for-ebgp-peers-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Bestpath: Compare routerID for eBGP peers"; | | "Bestpath: Compare routerID for eBGP peers"; |
| } | | } |
| leaf is-bestpath-aigp-ignore-enabled { | | leaf is-bestpath-aigp-ignore-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Bestpath: Ignore AIGP unless both paths have | | "Bestpath: Ignore AIGP unless both paths have |
| AIGP attribute"; | | AIGP attribute"; |
| } | | } |
| leaf is-bestpath-igp-metric-ignore-enabled { | | leaf is-bestpath-igp-metric-ignore-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Bestpath: Ignore IGP metric"; | | "Bestpath: Ignore IGP metric"; |
| } | | } |
| n | leaf is-bestpath-igp-metric-sr-policy-enabled { | n | |
| type boolean; | | |
| description | | |
| "Bestpath: Prefer SR-Policy admin/metric of | | |
| color-extcomm Nexthop as IGP metric"; | | |
| } | | |
| leaf is-multipath-as-path-ignore-onwards-enabled { | | leaf is-multipath-as-path-ignore-onwards-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Multipath: Ignore everything AS path onwards for | | "Multipath: Ignore everything AS path onwards for |
| mpath"; | | mpath"; |
| } | | } |
| n | leaf is-multipath-section-use-cluster-list-length { | n | |
| type boolean; | | |
| description | | |
| "Multipath: Use Cluster-List Length Criteria"; | | |
| } | | |
| leaf is-bestpath-sr-policy-prefer-enabled { | | |
| type boolean; | | |
| description | | |
| "Bestpath: Prefer SR policy path"; | | |
| } | | |
| leaf is-bestpath-sr-policy-force-enabled { | | |
| type boolean; | | |
| description | | |
| "Bestpath: Force SR policy path"; | | |
| } | | |
| leaf is-enforce-first-as-enabled { | | leaf is-enforce-first-as-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Enforce first AS"; | | "Enforce first AS"; |
| } | | } |
| leaf default-local-preference { | | leaf default-local-preference { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP global process default local preference"; | n | "Default local preference"; |
| } | | } |
| leaf keep-alive-time { | | leaf keep-alive-time { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "Default keepalive timer (seconds)"; | | "Default keepalive timer (seconds)"; |
| } | | } |
| leaf hold-time { | | leaf hold-time { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "Default hold timer (seconds)"; | | "Default hold timer (seconds)"; |
| } | | } |
| leaf min-acceptable-hold-time { | | leaf min-acceptable-hold-time { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "Default min acceptable hold time from | | "Default min acceptable hold time from |
| neighbor(seconds)"; | | neighbor(seconds)"; |
| } | | } |
| leaf is-neighbor-logging { | | leaf is-neighbor-logging { |
| type boolean; | | type boolean; |
| description | | description |
| "Neighbor logging enabled"; | | "Neighbor logging enabled"; |
| } | | } |
| leaf is-default-metric-configured { | | leaf is-default-metric-configured { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if default metric is configured"; | n | "Default metric configured"; |
| } | | } |
| leaf default-metric { | | leaf default-metric { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP global process virtual routingand forwarding | n | |
| default metric"; | | "Default metric"; |
| } | | } |
| leaf is-default-originate-configured { | | leaf is-default-originate-configured { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if default route originate is | n | "Default route originate configured"; |
| configured"; | | |
| } | | } |
| leaf is-graceful-restart { | | leaf is-graceful-restart { |
| type boolean; | | type boolean; |
| description | | description |
| "Graceful restart enabled"; | | "Graceful restart enabled"; |
| } | | } |
| leaf is-nsr { | | leaf is-nsr { |
| type boolean; | | type boolean; |
| description | | description |
| "Non-stop routing enabled"; | | "Non-stop routing enabled"; |
| } | | } |
| n | leaf slow-peer-global-dynamic { | n | |
| type boolean; | | |
| description | | |
| "Slow peer global dynamic"; | | |
| } | | |
| leaf slow-peer-global-dynamic-threshold { | | |
| type uint16; | | |
| description | | |
| "Slow peer global dynamic threshold (in sec)"; | | |
| } | | |
| leaf slow-peer-global-detection-disabled { | | |
| type boolean; | | |
| description | | |
| "Slow peer global detection disabled"; | | |
| } | | |
| leaf nexthop-validation-disabled { | | |
| type boolean; | | |
| description | | |
| "Color-Extcomm Nexthop validation disabled"; | | |
| } | | |
| leaf nexthop-validation-srte { | | |
| type boolean; | | |
| description | | |
| "Color-Extcomm Nexthop validation SR-Policy"; | | |
| } | | |
| leaf restart-time { | | leaf restart-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Restart time (in seconds)"; | | "Restart time (in seconds)"; |
| } | | } |
| leaf stale-path-time { | | leaf stale-path-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Stale path timeout time (in seconds)"; | | "Stale path timeout time (in seconds)"; |
| } | | } |
| leaf rib-purge-timeout { | | leaf rib-purge-timeout { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "RIB purge timeout time (in seconds)"; | | "RIB purge timeout time (in seconds)"; |
| } | | } |
| leaf rpki-use-validity { | | leaf rpki-use-validity { |
| type boolean; | | type boolean; |
| description | | description |
| "Use RPKI validity for bestpath calculation"; | | "Use RPKI validity for bestpath calculation"; |
| } | | } |
| leaf rpki-allow-invalid { | | leaf rpki-allow-invalid { |
| type boolean; | | type boolean; |
| description | | description |
| "Allow invalid paths"; | | "Allow invalid paths"; |
| } | | } |
| leaf rpki-signal-ibgp { | | leaf rpki-signal-ibgp { |
| type boolean; | | type boolean; |
| description | | description |
| "Signal RPKI validity to iBGP peers"; | | "Signal RPKI validity to iBGP peers"; |
| n | } | n | |
| leaf last-insert-reset-queue { | | |
| type uint64; | | |
| description | | |
| "Time when this neighbor was last inserted in | | |
| reset queue"; | | |
| } | | |
| leaf last-remove-reset-queue { | | |
| type uint64; | | |
| description | | |
| "Time when this neighbor was last removed from | | |
| reset queue"; | | |
| } | | } |
| } | | } |
| | | |
| grouping COLOR-ID-BAG { | | grouping COLOR-ID-BAG { |
| description | | description |
| "COLOR ID BAG"; | | "COLOR ID BAG"; |
| leaf color-id-val { | | leaf color-id-val { |
| type uint32; | | type uint32; |
| description | | description |
| "Color ID "; | | "Color ID "; |
| } | | } |
| n | leaf flags { | n | |
| type uint32; | | |
| description | | |
| "Color ID Flags"; | | |
| } | | |
| leaf odn-policy-type { | | |
| type Bgp-odn-policy; | | |
| description | | |
| "Color ID ODN Policy Type"; | | |
| } | | |
| } | | } |
| | | |
| grouping CLUSTER-ID-BAG { | | grouping CLUSTER-ID-BAG { |
| description | | description |
| "CLUSTER ID BAG"; | | "CLUSTER ID BAG"; |
| leaf cluster-id-val { | | leaf cluster-id-val { |
| type uint32; | | type uint32; |
| description | | description |
| "Cluster ID "; | | "Cluster ID "; |
| } | | } |
| leaf cluster-id-type { | | leaf cluster-id-type { |
| type uint8; | | type uint8; |
| description | | description |
| "Cluster ID type: number or IPv4 address"; | | "Cluster ID type: number or IPv4 address"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-GLOBAL-PROCESS-INFO-GBL { | | grouping BGP-GLOBAL-PROCESS-INFO-GBL { |
| description | | description |
| "BGP GLOBAL PROCESS INFO GBL"; | | "BGP GLOBAL PROCESS INFO GBL"; |
| n | container gshut-nbr-all-ts { | n | |
| description | | |
| "BGP gshut nbr all timestamp"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container gshut-nbr-all-age { | | |
| description | | |
| "BGP gshut nbr all age"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| leaf in-standalone-mode { | | leaf in-standalone-mode { |
| type boolean; | | type boolean; |
| description | | description |
| "Standalone or Distributed mode"; | | "Standalone or Distributed mode"; |
| } | | } |
| leaf local-as { | | leaf local-as { |
| type uint32; | | type uint32; |
| description | | description |
| "Local autonomous system number"; | | "Local autonomous system number"; |
| } | | } |
| leaf instance-name { | | leaf instance-name { |
| type string; | | type string; |
| description | | description |
| "Name of BGP instance"; | | "Name of BGP instance"; |
| n | } | n | |
| leaf platform-max-multi-paths { | | |
| type uint32; | | |
| description | | |
| "Platform supported maximum multi-path count"; | | |
| } | | } |
| leaf restart-count { | | leaf restart-count { |
| type uint32; | | type uint32; |
| description | | description |
| "No of times BGP has started"; | | "No of times BGP has started"; |
| } | | } |
| leaf update-delay { | | leaf update-delay { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Update delay timeout time (in seconds)"; | | "Update delay timeout time (in seconds)"; |
| } | | } |
| leaf generic-scan-period { | | leaf generic-scan-period { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "Period (in seconds) of generic scanner runs"; | | "Period (in seconds) of generic scanner runs"; |
| } | | } |
| leaf confederation-id { | | leaf confederation-id { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP global process confederation ID"; | n | "Confederation ID"; |
| } | | } |
| leaf cluster-id { | | leaf cluster-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Cluster ID"; | | "Cluster ID"; |
| } | | } |
| leaf configured-cluster-id { | | leaf configured-cluster-id { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP global process configuredcluster ID"; | n | "Configured cluster ID"; |
| } | | } |
| leaf is-cluster-id-specified-as-ip { | | leaf is-cluster-id-specified-as-ip { |
| type boolean; | | type boolean; |
| description | | description |
| "Cluster ID specified as an IP address"; | | "Cluster ID specified as an IP address"; |
| } | | } |
| leaf asn-format { | | leaf asn-format { |
| type uint32; | | type uint32; |
| description | | description |
| "BGP AS Number Format"; | | "BGP AS Number Format"; |
| } | | } |
| leaf srgb-start-configured { | | leaf srgb-start-configured { |
| type uint32; | | type uint32; |
| description | | description |
| "Configured segment-routing Global Block start | | "Configured segment-routing Global Block start |
| value"; | | value"; |
| } | | } |
| leaf srgb-end-configured { | | leaf srgb-end-configured { |
| type uint32; | | type uint32; |
| description | | description |
| "Configured segment-routing Global Block end | | "Configured segment-routing Global Block end |
| value"; | | value"; |
| } | | } |
| leaf srgb-start { | | leaf srgb-start { |
| type uint32; | | type uint32; |
| description | | description |
| "In use segment-routing Global Block start value"; | | "In use segment-routing Global Block start value"; |
| } | | } |
| leaf srgb-end { | | leaf srgb-end { |
| type uint32; | | type uint32; |
| description | | description |
| "In use Segment-routing Global Block end value"; | | "In use Segment-routing Global Block end value"; |
| } | | } |
| n | leaf srlb-start-configured { | n | |
| type uint32; | | |
| description | | |
| "Configured segment-routing Local Block start | | |
| value"; | | |
| } | | |
| leaf srlb-end-configured { | | |
| type uint32; | | |
| description | | |
| "Configured segment-routing Local Block end value"; | | |
| } | | |
| leaf srlb-start { | | |
| type uint32; | | |
| description | | |
| "In use segment-routing Local Block start value"; | | |
| } | | |
| leaf srlb-end { | | |
| type uint32; | | |
| description | | |
| "In use Segment-routing Local Block end value"; | | |
| } | | |
| leaf mix-srte-native { | | |
| type boolean; | | |
| description | | |
| "Platform support mix of SR-TE and Native IGP | | |
| Nexthop"; | | |
| } | | |
| leaf graceful-maintenance { | | leaf graceful-maintenance { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Graceful shutdown activated for allneighbors"; | n | "Graceful Maintenance"; |
| } | | } |
| leaf graceful-maint-all-nbrs { | | leaf graceful-maint-all-nbrs { |
| type boolean; | | type boolean; |
| description | | description |
| "Graceful Maintenance also for neighbors without | | "Graceful Maintenance also for neighbors without |
| GM configuration"; | | GM configuration"; |
| } | | } |
| leaf graceful-maint-retain-routes { | | leaf graceful-maint-retain-routes { |
| type boolean; | | type boolean; |
| description | | description |
| "Retaining routes in RIB when BGP process stops | | "Retaining routes in RIB when BGP process stops |
| while in Graceful Maintenance"; | | while in Graceful Maintenance"; |
| } | | } |
| leaf process-rlimit { | | leaf process-rlimit { |
| type uint64; | | type uint64; |
| description | | description |
| "Platform RLIMIT max for the process"; | | "Platform RLIMIT max for the process"; |
| } | | } |
| leaf bmp-maximum-buffer-size { | | leaf bmp-maximum-buffer-size { |
| type uint64; | | type uint64; |
| description | | description |
| "Maximum limit user can configure for | | "Maximum limit user can configure for |
| max-buffer-size command under bmp-server"; | | max-buffer-size command under bmp-server"; |
| } | | } |
| leaf bmp-default-buffer-size { | | leaf bmp-default-buffer-size { |
| type uint64; | | type uint64; |
| description | | description |
| "Default value for BMP buffer limit when a value | | "Default value for BMP buffer limit when a value |
| is not configured"; | | is not configured"; |
| } | | } |
| leaf bmp-current-buffer-size { | | leaf bmp-current-buffer-size { |
| type uint64; | | type uint64; |
| description | | description |
| "Current value for BMP buffer "; | | "Current value for BMP buffer "; |
| } | | } |
| leaf bmp-cur-maximum-buffer-size { | | leaf bmp-cur-maximum-buffer-size { |
| type uint64; | | type uint64; |
| description | | description |
| "Maximum limit user has configure using | | "Maximum limit user has configure using |
| max-buffer-size command under bmp-server"; | | max-buffer-size command under bmp-server"; |
| n | } | n | |
| leaf gbl-srv6-locator { | | |
| type string; | | |
| description | | |
| "Global Srv6 Locator Name"; | | |
| } | | |
| leaf gbl-usid-alloc-mode { | | |
| type Bgp-usid-alloc-mode; | | |
| description | | |
| "Global uSID LIB allocation mode"; | | |
| } | | |
| leaf lpts-secure-binding { | | |
| type boolean; | | |
| description | | |
| "Enable LPTS secure binding for eBGP | | |
| directly-connected neighbor"; | | |
| } | | } |
| list cluster-id-entry { | | list cluster-id-entry { |
| description | | description |
| "All configured Cluster IDs"; | | "All configured Cluster IDs"; |
| uses CLUSTER-ID-BAG; | | uses CLUSTER-ID-BAG; |
| } | | } |
| list color-id { | | list color-id { |
| description | | description |
| "All configured Color IDs"; | | "All configured Color IDs"; |
| uses COLOR-ID-BAG; | | uses COLOR-ID-BAG; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-GLOBAL-PROCESS-INFO-BAG { | | grouping BGP-GLOBAL-PROCESS-INFO-BAG { |
| description | | description |
| "BGP process information common to all BGP | | "BGP process information common to all BGP |
| processes"; | | processes"; |
| container global { | | container global { |
| description | | description |
| "Global information"; | | "Global information"; |
| uses BGP-GLOBAL-PROCESS-INFO-GBL; | | uses BGP-GLOBAL-PROCESS-INFO-GBL; |
| } | | } |
| container vrf { | | container vrf { |
| description | | description |
| "VRF information"; | | "VRF information"; |
| uses BGP-GLOBAL-PROCESS-INFO-VRF; | | uses BGP-GLOBAL-PROCESS-INFO-VRF; |
| } | | } |
| leaf vrf-name { | | leaf vrf-name { |
| type string; | | type string; |
| description | | description |
| "Name of the VRF"; | | "Name of the VRF"; |
| } | | } |
| leaf vrfid { | | leaf vrfid { |
| type uint32; | | type uint32; |
| description | | description |
| "VRF ID"; | | "VRF ID"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-POSTIT-INFO { | | grouping BGP-POSTIT-INFO { |
| description | | description |
| "BGP POSTIT INFO"; | | "BGP POSTIT INFO"; |
| container postit-notification { | | container postit-notification { |
| description | | description |
| n | "Time since last notification was sent or | n | "Postit notification"; |
| received"; | | |
| uses BGP-NOTFNTYPE; | | uses BGP-NOTFNTYPE; |
| } | | } |
| leaf postit-type { | | leaf postit-type { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Type of the event for post-it"; | n | "Postit Type"; |
| } | | } |
| leaf postit-subtype { | | leaf postit-subtype { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP Postit Subtype"; | n | "Postit Subtype"; |
| } | | } |
| leaf postit-flags { | | leaf postit-flags { |
| type uint8; | | type uint8; |
| description | | description |
| n | "Flags associated with post-it"; | n | "Postit Flags"; |
| } | | } |
| leaf postit-af-name { | | leaf postit-af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Postit Afi"; | | "Postit Afi"; |
| } | | } |
| leaf postit-ts { | | leaf postit-ts { |
| type uint64; | | type uint64; |
| description | | description |
| "Postit TS"; | | "Postit TS"; |
| } | | } |
| leaf postit-direction { | | leaf postit-direction { |
| type uint8; | | type uint8; |
| description | | description |
| n | "BGP postit inbound oroutbound direction"; | n | "Postit Direction"; |
| } | | } |
| leaf postit-id { | | leaf postit-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Postit ID"; | | "Postit ID"; |
| } | | } |
| leaf peer-id { | | leaf peer-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Peer ID"; | | "Peer ID"; |
| } | | } |
| leaf postit-policy { | | leaf postit-policy { |
| type string; | | type string; |
| description | | description |
| "Policy"; | | "Policy"; |
| } | | } |
| leaf postit-reset { | | leaf postit-reset { |
| type Bgp-reset-reason-index; | | type Bgp-reset-reason-index; |
| description | | description |
| "Reset"; | | "Reset"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-NEIGHBOR-NSR-BAG { | | grouping BGP-NEIGHBOR-NSR-BAG { |
| description | | description |
| "BGP neighbor nsr bag"; | | "BGP neighbor nsr bag"; |
| container neighbors-address { | | container neighbors-address { |
| description | | description |
| "Neighbor Addr"; | | "Neighbor Addr"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| leaf vrf-name { | | leaf vrf-name { |
| type string; | | type string; |
| description | | description |
| "VRF Name"; | | "VRF Name"; |
| } | | } |
| leaf connect-state { | | leaf connect-state { |
| type uint32; | | type uint32; |
| description | | description |
| "State"; | | "State"; |
| } | | } |
| leaf start-time { | | leaf start-time { |
| type uint32; | | type uint32; |
| description | | description |
| "StartTime"; | | "StartTime"; |
| } | | } |
| leaf nsr-state { | | leaf nsr-state { |
| type Bgp-sync-nbr-nsr-state; | | type Bgp-sync-nbr-nsr-state; |
| description | | description |
| "NSR state"; | | "NSR state"; |
| } | | } |
| list neighbor-af { | | list neighbor-af { |
| min-elements 25; | | min-elements 25; |
| max-elements "25"; | | max-elements "25"; |
| description | | description |
| "Neighbor Afi"; | | "Neighbor Afi"; |
| leaf entry { | | leaf entry { |
| type boolean; | | type boolean; |
| description | | description |
| "Array entry."; | | "Array entry."; |
| } | | } |
| } | | } |
| list postit-info { | | list postit-info { |
| description | | description |
| n | "BGP neighbor postit rounting information"; | n | "Postit Info"; |
| uses BGP-POSTIT-INFO; | | uses BGP-POSTIT-INFO; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPDFILTER-VRF-BAG { | | grouping BGP-UPDFILTER-VRF-BAG { |
| description | | description |
| "BGP Update filtering VRF information"; | | "BGP Update filtering VRF information"; |
| container last-update-filtered-timestamp { | | container last-update-filtered-timestamp { |
| description | | description |
| "Last Filtered messages received time: time | | "Last Filtered messages received time: time |
| elapsed since 00:00:00 UTC, January 1, 1970"; | | elapsed since 00:00:00 UTC, January 1, 1970"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| leaf update-vrf-name { | | leaf update-vrf-name { |
| type string; | | type string; |
| description | | description |
| "VRF Name"; | | "VRF Name"; |
| } | | } |
| leaf update-filtered-message-count { | | leaf update-filtered-message-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of filtered messages"; | n | "Filtered messages count"; |
| } | | } |
| leaf update-filtered-neighbor-count { | | leaf update-filtered-neighbor-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Count of neighbors that received filtered | | "Count of neighbors that received filtered |
| messages"; | | messages"; |
| } | | } |
| leaf last-update-filtered-age { | | leaf last-update-filtered-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last filtered messages received event | | "Time since last filtered messages received event |
| (in seconds)"; | | (in seconds)"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-VRF-INFO-BAG { | | grouping BGP-VRF-INFO-BAG { |
| description | | description |
| "BGP VRF information bag"; | | "BGP VRF information bag"; |
| leaf route-distinguisher { | | leaf route-distinguisher { |
| type xr:Route-dist; | | type xr:Route-dist; |
| description | | description |
| n | "BGP virtual routing and forwardingroute | n | |
| distinguisher"; | | "Route Distinguisher"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-PFXLST { | | grouping BGP-PFXLST { |
| description | | description |
| "Prefix list entry"; | | "Prefix list entry"; |
| list bgp-pfxlst { | | list bgp-pfxlst { |
| description | | description |
| n | "Next entry in prefix list"; | n | "bgp pfxlst"; |
| container bgp-prefix { | | container bgp-prefix { |
| description | | description |
| "BGP prefix"; | | "BGP prefix"; |
| uses BGP-PREFIXTYPE; | | uses BGP-PREFIXTYPE; |
| } | | } |
| leaf sequence-number { | | leaf sequence-number { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Sequence number of the entry in the prefix-list"; | n | "Sequence number"; |
| } | | } |
| leaf is-prefix-grant { | | leaf is-prefix-grant { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE = permit, FALSE = deny"; | | "TRUE = permit, FALSE = deny"; |
| } | | } |
| leaf min-prefix-length { | | leaf min-prefix-length { |
| type uint8; | | type uint8; |
| n | units "bit"; | n | |
| description | | description |
| n | "Minimum prefix length in bits"; | n | "Minimum prefix length"; |
| } | | } |
| leaf max-prefix-length { | | leaf max-prefix-length { |
| type uint8; | | type uint8; |
| n | units "bit"; | n | |
| description | | description |
| n | "Maximum prefix length in bits"; | n | "Maximum prefix length"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping BGP-RCV-PFXLST-BAG { | | grouping BGP-RCV-PFXLST-BAG { |
| description | | description |
| "Received prefix filter"; | | "Received prefix filter"; |
| container neighbor-address-xr { | | container neighbor-address-xr { |
| description | | description |
| "Neighbor Address"; | | "Neighbor Address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container prefix-list-info { | | container prefix-list-info { |
| description | | description |
| "Prefix list"; | | "Prefix list"; |
| uses BGP-PFXLST; | | uses BGP-PFXLST; |
| } | | } |
| leaf af-name { | | leaf af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Address family identfier"; | | "Address family identfier"; |
| } | | } |
| } | | } |
| | | |
| n | grouping BGP-DEP-ENTRY-INFO { | n | grouping BGP-UPDGEN-AF-BAG { |
| | | description |
| | | "BGP Update generation address-family information"; |
| | | container update-statistics { |
| description | | description |
| "BGP DEP ENTRY INFO"; | | "Upate statistics"; |
| leaf tblid { | | uses BGP-UPDGEN-STATS-BAG; |
| | | } |
| | | leaf update-group-af-name { |
| | | type Bgp-afi; |
| | | description |
| | | "Address family identifier"; |
| | | } |
| | | leaf update-main-table-version { |
| | | type uint32; |
| | | description |
| | | "Main table version"; |
| | | } |
| | | leaf update-rib-version { |
| | | type uint32; |
| | | description |
| | | "RIB version"; |
| | | } |
| | | leaf update-min-neighbor-version { |
| | | type uint32; |
| | | description |
| | | "Minimum Neighbor version"; |
| | | } |
| | | leaf current-update-limit-af { |
| | | type uint32; |
| | | description |
| | | "Current AF update limit"; |
| | | } |
| | | leaf configured-update-limit-af { |
| | | type uint32; |
| | | description |
| | | "Configured AF update limit"; |
| | | } |
| | | leaf current-update-limit-subgrp-ebgp { |
| | | type uint32; |
| | | description |
| | | "Current EBGP sub-group update limit"; |
| | | } |
| | | leaf configured-update-limit-subgrp-ebgp { |
| | | type uint32; |
| | | description |
| | | "Configured EBGP sub-group update limit"; |
| | | } |
| | | leaf current-update-limit-sub-group-ibgp { |
| | | type uint32; |
| | | description |
| | | "Current IBGP sub-group update limit"; |
| | | } |
| | | leaf configured-update-limit-sub-group-ibgp { |
| | | type uint32; |
| | | description |
| | | "Configured IBGP sub-group update limit"; |
| | | } |
| | | leaf update-out-queue-messages { |
| | | type uint32; |
| | | description |
| | | "OutQueue messsages"; |
| | | } |
| | | leaf update-out-queue-size { |
| | | type uint32; |
| | | description |
| | | "OutQueue size"; |
| | | } |
| | | leaf update-throttled { |
| | | type boolean; |
| | | description |
| | | "Is Update throttled"; |
| | | } |
| | | leaf update-update-group-count { |
| | | type uint32; |
| | | description |
| | | "Update-group count"; |
| | | } |
| | | leaf update-sub-group-count { |
| | | type uint32; |
| | | description |
| | | "Sub-group count"; |
| | | } |
| | | leaf sub-group-throttled-count { |
| | | type uint32; |
| | | description |
| | | "Throttled sub-group count"; |
| | | } |
| | | leaf refresh-sub-group-count { |
| | | type uint32; |
| | | description |
| | | "Refresh sub-group count"; |
| | | } |
| | | leaf refresh-sub-group-throttled-count { |
| | | type uint32; |
| | | description |
| | | "Throttled refresh sub-group count"; |
| | | } |
| | | leaf filter-group-count { |
| | | type uint32; |
| | | description |
| | | "Filter-group count"; |
| | | } |
| | | leaf neighbor-count { |
| | | type uint32; |
| | | description |
| | | "Neighbor count"; |
| | | } |
| | | leaf update-table-vrf-name { |
| | | type string; |
| | | description |
| | | "VRF Name"; |
| | | } |
| | | leaf update-vrfaf-name { |
| | | type uint32; |
| | | description |
| | | "Address family identifier"; |
| | | } |
| | | leaf update-vrf-rd-version { |
| | | type uint32; |
| | | description |
| | | "RD Version"; |
| | | } |
| | | leaf update-vrf-table-rib-version { |
| | | type uint32; |
| | | description |
| | | "VRF Table RIB version"; |
| | | } |
| | | leaf table-update-group-count { |
| | | type uint32; |
| | | description |
| | | "VRF Table update-group count"; |
| | | } |
| | | leaf update-table-sub-group-count { |
| | | type uint32; |
| | | description |
| | | "VRF Table sub-group count"; |
| | | } |
| | | leaf table-sub-group-throttled-count { |
| | | type uint32; |
| | | description |
| | | "VRF Table throttled sub-group count"; |
| | | } |
| | | leaf table-refresh-sub-group-count { |
| | | type uint32; |
| | | description |
| | | "VRF Table refresh sub-group count"; |
| | | } |
| | | leaf table-refresh-sub-group-throttled-count { |
| | | type uint32; |
| | | description |
| | | "VRF Table throttled refresh sub-group count"; |
| | | } |
| | | leaf update-table-filter-group-count { |
| | | type uint32; |
| | | description |
| | | "VRF Table filter-group count"; |
| | | } |
| | | leaf table-neighbor-count { |
| | | type uint32; |
| | | description |
| | | "VRF Table neighbor count"; |
| | | } |
| | | } |
| | | |
| | | grouping BGP-UPDGEN-NBR-BAG { |
| | | description |
| | | "BGP Update generation Neighbor information"; |
| | | container update-neighbor-address { |
| | | description |
| | | "Neighbor address"; |
| | | uses BGP-ADDRTYPE; |
| | | } |
| | | container last-sub-group-add-timestamp { |
| | | description |
| | | "Last added time"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container last-sub-group-remove-timestamp { |
| | | description |
| | | "Last removed time"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container last-filter-group-add-timestamp { |
| | | description |
| | | "Last added time"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container last-filter-group-remove-timestamp { |
| | | description |
| | | "Last removed time"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container first-default-originate-timestamp { |
| | | description |
| | | "First default-origination time"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container last-default-originate-timestamp { |
| | | description |
| | | "Last default-origination time"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container last-update-group-start-timestamp { |
| | | description |
| | | "Last update-group timer start"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container last-update-group-expiry-timestamp { |
| | | description |
| | | "Last update-group timer expiry"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container first-update-queued-timestamp { |
| | | description |
| | | "First update queued time"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container last-update-queued-timestamp { |
| | | description |
| | | "Last update queued time"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container last-refresh-update-queued-timestamp { |
| | | description |
| | | "Last refresh update queued time"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container first-update-write-timestamp { |
| | | description |
| | | "First update write time"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container last-update-write-timestamp { |
| | | description |
| | | "Last update write time"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container last-refresh-update-write-timestamp { |
| | | description |
| | | "Last refresh update write time"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container update-statistics { |
| | | description |
| | | "Update statistics"; |
| | | uses BGP-UPDGEN-STATS-BAG; |
| | | } |
| | | leaf process-id { |
| | | type uint32; |
| | | description |
| | | "ProcessID"; |
| | | } |
| | | leaf update-vrf-name { |
| | | type string; |
| | | description |
| | | "VRF Name"; |
| | | } |
| | | leaf update-group-af-name { |
| | | type Bgp-afi; |
| | | description |
| | | "Address family identifier"; |
| | | } |
| | | leaf update-filter-group-index { |
| | | type uint32; |
| | | description |
| | | "Filter-group index"; |
| | | } |
| | | leaf refresh-filter-group-index { |
| | | type uint32; |
| | | description |
| | | "Refresh Filter-group index"; |
| | | } |
| | | leaf sub-group-index-xr { |
| | | type uint32; |
| | | description |
| | | "Sub-group index"; |
| | | } |
| | | leaf refresh-sub-group-index { |
| | | type uint32; |
| | | description |
| | | "Refresh Sub-group index"; |
| | | } |
| | | leaf refresh-sub-group-id { |
| | | type uint32; |
| | | description |
| | | "Refresh sub-group ID"; |
| | | } |
| | | leaf update-group-index-xr { |
| | | type uint32; |
| | | description |
| | | "Update-group index"; |
| | | } |
| | | leaf update-main-table-version { |
| | | type uint32; |
| | | description |
| | | "Main table version"; |
| | | } |
| | | leaf update-vrf-table-rib-version { |
| | | type uint32; |
| | | description |
| | | "VRF Table RIB version"; |
| | | } |
| | | leaf update-out-queue-messages { |
| | | type uint32; |
| | | description |
| | | "OutQueue messages"; |
| | | } |
| | | leaf update-out-queue-size { |
| | | type uint32; |
| | | description |
| | | "OutQueue size"; |
| | | } |
| | | leaf refresh-update-out-queue-messages { |
| | | type uint32; |
| | | description |
| | | "Refresh OutQueue messages"; |
| | | } |
| | | leaf refresh-update-out-queue-size { |
| | | type uint32; |
| | | description |
| | | "Refresh OutQueue size"; |
| | | } |
| | | leaf update-filter-group-messages { |
| | | type uint32; |
| | | description |
| | | "Filter-group messages"; |
| | | } |
| | | leaf version { |
| | | type uint32; |
| | | description |
| | | "Version"; |
| | | } |
| | | leaf pending-target-version { |
| | | type uint32; |
| | | description |
| | | "Pending target version"; |
| | | } |
| | | leaf next-resume-version { |
| | | type uint32; |
| | | description |
| | | "Resume version"; |
| | | } |
| | | leaf ack-version { |
| | | type uint32; |
| | | description |
| | | "Ack version"; |
| | | } |
| | | leaf synced-ack-version { |
| | | type uint32; |
| | | description |
| | | "Synced ack version"; |
| | | } |
| | | leaf outstanding-version-count { |
| | | type uint32; |
| | | description |
| | | "Outstanding version count"; |
| | | } |
| | | leaf update-refresh-version { |
| | | type uint32; |
| | | description |
| | | "Refresh version"; |
| | | } |
| | | leaf refresh-requested-target-version { |
| | | type uint32; |
| | | description |
| | | "Requested refresh target version"; |
| | | } |
| | | leaf update-refresh-target-version { |
| | | type uint32; |
| | | description |
| | | "Refresh target version"; |
| | | } |
| | | leaf refresh-pending-target-version { |
| | | type uint32; |
| | | description |
| | | "Pending refresh target version"; |
| | | } |
| | | leaf refresh-next-resume-version { |
| | | type uint32; |
| | | description |
| | | "Refresh resume version"; |
| | | } |
| | | leaf refresh-ack-version { |
| | | type uint32; |
| | | description |
| | | "Refresh Ack version"; |
| | | } |
| | | leaf last-default-originate-age { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time since last default-origination event (in |
| | | seconds)"; |
| | | } |
| | | leaf default-originate-state { |
| type uint32; | | type int32; |
| | | description |
| | | "Default-origination state"; |
| | | } |
| | | leaf default-originate-internal-context { |
| | | type int32; |
| | | description |
| | | "Default-origination context"; |
| | | } |
| | | leaf is-eor-outstanding { |
| | | type boolean; |
| | | description |
| | | "Number of EORs outstanding"; |
| | | } |
| | | leaf outbound-refresh-count { |
| | | type uint32; |
| | | description |
| | | "Refresh Outbound count"; |
| | | } |
| | | leaf inbound-refresh-count { |
| | | type uint32; |
| | | description |
| | | "Refresh Inbound count"; |
| | | } |
| | | leaf is-update-group-timer-running { |
| | | type boolean; |
| | | description |
| | | "Is update-group timer running"; |
| | | } |
| | | leaf current-update-group-af-name { |
| | | type Bgp-afi; |
| | | description |
| | | "Current Update-group address-family identifier"; |
| | | } |
| | | leaf last-update-group-af-name { |
| | | type Bgp-afi; |
| | | description |
| | | "Last Update-group address-family identifier"; |
| | | } |
| | | leaf last-update-queued-age { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time since last update queued event (in seconds)"; |
| | | } |
| | | leaf last-refresh-update-queued-age { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time since last refresh update queued event (in |
| | | seconds)"; |
| | | } |
| | | leaf last-update-write-age { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time since last update write event (in seconds)"; |
| | | } |
| | | leaf last-refresh-update-write-age { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time since last refresh update write event (in |
| | | seconds)"; |
| | | } |
| | | } |
| | | |
| | | grouping BGP-NBR-GSHUT { |
| | | description |
| | | "BGP NBR GSHUT"; |
| | | leaf gshut-exists { |
| | | type boolean; |
| | | description |
| | | "Graceful Maintenance enabled"; |
| | | } |
| | | leaf gshut-local-active { |
| | | type boolean; |
| | | description |
| | | "Graceful Maintenance locally activated"; |
| | | } |
| | | leaf gshut-active { |
| | | type boolean; |
| | | description |
| | | "Graceful Maintenance activated"; |
| | | } |
| | | leaf gshut-locpref-set { |
| | | type boolean; |
| | | description |
| | | "Graceful Maintenance Local Preference set"; |
| | | } |
| | | leaf gshut-locpref { |
| | | type uint32; |
| | | description |
| | | "Graceful Maintenance Local Preference"; |
| | | } |
| | | leaf gshut-prepends { |
| | | type uint8; |
| | | description |
| | | "Graceful Maintenance number of AS prepends"; |
| | | } |
| | | } |
| | | |
| | | grouping BGP-NBR-MSG-STATS-UNIT { |
| | | description |
| | | "BGP NBR MSG STATS UNIT"; |
| | | container last-time-spec { |
| | | description |
| | | "Last timespec"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | leaf count { |
| | | type uint32; |
| | | description |
| | | "Count"; |
| | | } |
| | | } |
| | | |
| | | grouping BGP-NBR-MSG-STATS-OP { |
| | | description |
| | | "BGP NBR MSG STATS OP"; |
| | | container tx { |
| | | description |
| | | "Transmit"; |
| | | uses BGP-NBR-MSG-STATS-UNIT; |
| | | } |
| | | container rx { |
| | | description |
| | | "Receive"; |
| | | uses BGP-NBR-MSG-STATS-UNIT; |
| | | } |
| | | } |
| | | |
| | | grouping BGP-NBR-MSG-STATS { |
| | | description |
| | | "BGP NBR MSG STATS"; |
| | | container open { |
| | | description |
| | | "Open"; |
| | | uses BGP-NBR-MSG-STATS-OP; |
| | | } |
| | | container notification { |
| | | description |
| | | "Notification"; |
| | | uses BGP-NBR-MSG-STATS-OP; |
| | | } |
| | | container update { |
| | | description |
| | | "Update"; |
| | | uses BGP-NBR-MSG-STATS-OP; |
| | | } |
| | | container keepalive { |
| | | description |
| | | "Keepalive"; |
| | | uses BGP-NBR-MSG-STATS-OP; |
| | | } |
| | | container route-refresh { |
| | | description |
| | | "Route refresh"; |
| | | uses BGP-NBR-MSG-STATS-OP; |
| | | } |
| | | container total { |
| | | description |
| | | "Total"; |
| | | uses BGP-NBR-MSG-STATS-OP; |
| | | } |
| | | } |
| | | |
| | | grouping BGP-PERF-NBR-AF { |
| | | description |
| | | "BGP PERF NBR AF"; |
| | | leaf sub-group-pending-message-count { |
| | | type uint32; |
| | | description |
| | | "No. of sub-group messages waiting to be sent out |
| | | on this neighbor -- DEPRECATED -- "; |
| | | } |
| | | leaf processed-messages { |
| | | type uint32; |
| | | description |
| | | "Number of messages processed from the neighbor's |
| | | write queue"; |
| | | } |
| | | leaf sent-messages { |
| | | type uint32; |
| | | description |
| | | "Number of messages sent from the neighbor's |
| | | write queue"; |
| | | } |
| | | leaf split-horizon-update-transmit { |
| | | type uint32; |
| | | description |
| | | "No. of update messages with split-horizon flag |
| | | that were sent out"; |
| | | } |
| | | leaf split-horizon-update-blocked { |
| | | type uint32; |
| | | description |
| | | "No. of update messages with split-horizon flag |
| | | that were blocked"; |
| | | } |
| | | leaf split-horizon-withdraw-transmit { |
| | | type uint32; |
| | | description |
| | | "No. of withdraw messages with split-horizon flag |
| | | that were sent out"; |
| | | } |
| | | leaf split-horizon-withdraw-blocked { |
| | | type uint32; |
| | | description |
| | | "No. of withdraw messages with split-horizon flag |
| | | that were blocked"; |
| | | } |
| | | } |
| | | |
| | | grouping BGP-NBR-AF { |
| | | description |
| | | "BGP neighbor address family specific information"; |
| | | container neighbor-af-performance-statistics { |
| | | description |
| | | "Neighbor AF statistics"; |
| | | uses BGP-PERF-NBR-AF; |
| | | } |
| | | leaf af-name { |
| | | type Bgp-afi; |
| | | description |
| | | "Address family identifier"; |
| | | } |
| | | leaf is-neighbor-route-reflector-client { |
| | | type boolean; |
| | | description |
| | | "Nbr is a route reflector client"; |
| | | } |
| | | leaf is-legacy-pe-rt { |
| | | type boolean; |
| | | description |
| | | "Nbr accepts route from legacy PE for |
| | | RT-Constraint AF "; |
| | | } |
| | | leaf is-neighbor-af-capable { |
| | | type boolean; |
| | | description |
| | | "Address family capability received from neighbor"; |
| | | } |
| | | leaf is-soft-reconfiguration-inbound-allowed { |
| | | type boolean; |
| | | description |
| | | "Inbound soft reconfiguration allowed"; |
| | | } |
| | | leaf is-use-soft-reconfiguration-always-on { |
| | | type boolean; |
| | | description |
| | | "Soft reconf overrides route refresh"; |
| | | } |
| | | leaf remove-private-as-from-updates { |
| | | type boolean; |
| | | description |
| | | "Private AS numbers removed from updates to this |
| | | nbr"; |
| | | } |
| | | leaf remove-private-as-entire-aspath-from-updates { |
| | | type boolean; |
| | | description |
| | | "Private AS numbers removed from updates to |
| | | thisnbr only if the aspath hasonly private ASes"; |
| | | } |
| | | leaf remove-private-as-from-inbound-updates { |
| | | type boolean; |
| | | description |
| | | "Private AS numbers removed from updates from |
| | | this nbr"; |
| | | } |
| | | leaf remove-private-as-entire-aspath-from-inbound-updates { |
| | | type boolean; |
| | | description |
| | | "Private AS numbers removed from updates from |
| | | this nbr only if the aspath has only private |
| | | ASes"; |
| | | } |
| | | leaf flowspec-validation-d-isable { |
| | | type boolean; |
| | | description |
| | | "Flowspec Validation Disabled"; |
| | | } |
| | | leaf flowspec-redirect-validation-d-isable { |
| | | type boolean; |
| | | description |
| | | "Flowspec Redirect Validation Disabled"; |
| | | } |
| | | leaf orr-group-name { |
| | | type string; |
| | | description |
| | | "ORR Group Name"; |
| | | } |
| | | leaf orr-group-index { |
| | | type uint32; |
| | | description |
| | | "ORR Group Index"; |
| | | } |
| | | leaf is-orr-root-address-configured { |
| | | type boolean; |
| | | description |
| | | "ORR Root address configuredfor the neighbor |
| | | connection"; |
| | | } |
| | | leaf advertise-afi { |
| | | type boolean; |
| | | description |
| | | "Encode in Advertise AFI"; |
| | | } |
| | | leaf advertise-afi-reorg { |
| | | type boolean; |
| | | description |
| | | "Encode in Advertise AFI"; |
| | | } |
| | | leaf advertise-afi-disable { |
| | | type boolean; |
| | | description |
| | | "Encode in Advertise AFI"; |
| | | } |
| | | leaf encapsulation-type { |
| | | type uint32; |
| | | description |
| | | "Encapsulation type"; |
| | | } |
| | | leaf advertise-rt-type { |
| | | type uint8; |
| | | description |
| | | "Advertise RT type"; |
| | | } |
| | | leaf advertise-afi-def-vrf-imp-disable { |
| | | type boolean; |
| | | description |
| | | "Advertise of default VRF import disable"; |
| | | } |
| | | leaf advertise-evpnv4-afi-def-vrf-imp-disable { |
| | | type boolean; |
| | | description |
| | | "Advertise of v4 default VRF import disable"; |
| | | } |
| | | leaf advertise-evpnv6-afi-def-vrf-imp-disable { |
| | | type boolean; |
| | | description |
| | | "Advertise of v6 default VRF import disable"; |
| | | } |
| | | leaf advertise-afi-vrf-re-imp-disable { |
| | | type boolean; |
| | | description |
| | | "Advertise of VRF re-import disable"; |
| | | } |
| | | leaf advertise-evpnv4-afi-vrf-re-imp-disable { |
| | | type boolean; |
| | | description |
| | | "Advertise of v4 VRF re-import disable"; |
| | | } |
| | | leaf advertise-evpnv6-afi-vrf-re-imp-disable { |
| | | type boolean; |
| | | description |
| | | "Advertise of v6 VRF re-import disable"; |
| | | } |
| | | leaf advertise-afi-eo-r-ready { |
| | | type boolean; |
| | | description |
| | | "EoR Can be sent for Advertise AFI"; |
| | | } |
| | | leaf always-use-next-hop-local { |
| | | type boolean; |
| | | description |
| | | "Local router always used for next-hop"; |
| | | } |
| | | leaf sent-community-to-neighbor { |
| | | type boolean; |
| | | description |
| | | "Community attribute sent to neighbor"; |
| | | } |
| | | leaf sent-gshut-community-to-neighbor { |
| | | type boolean; |
| | | description |
| | | "GSHUT Community attribute sent to neighbor"; |
| | | } |
| | | leaf sent-extended-community-to-neighbor { |
| | | type boolean; |
| | | description |
| | | "Extended community attribute sent to neighbor"; |
| | | } |
| | | leaf default-originate-vpn-index { |
| | | type uint32; |
| | | description |
| | | "Default orig vpn indexto find bitfield for a nbr |
| | | af"; |
| | | } |
| | | leaf neighbor-default-originate { |
| | | type boolean; |
| | | description |
| | | "Neighbor originates default"; |
| | | } |
| | | leaf is-orf-sent { |
| | | type boolean; |
| | | description |
| | | "Outbound route filter sent to neighbor"; |
| | | } |
| | | leaf is-update-deferred { |
| | | type boolean; |
| | | description |
| | | "Update deferred until ORF/route refresh received"; |
| | | } |
| | | leaf is-orf-send-scheduled { |
| | | type boolean; |
| | | description |
| | | "Scheduled to send prefix based ORF"; |
| | | } |
| | | leaf update-group-number { |
| | | type uint32; |
| | | description |
| | | "Update group index"; |
| | | } |
| | | leaf filter-group-index { |
| | | type uint32; |
| | | description |
| | | "Filter group index"; |
| | | } |
| | | leaf is-update-throttled { |
| | | type boolean; |
| | | description |
| | | "Updates Throttled becausewrite limit is reached"; |
| | | } |
| | | leaf is-update-leaving { |
| | | type boolean; |
| | | description |
| | | "Nbr leaving update-groupto another"; |
| | | } |
| | | leaf vpn-update-gen-enabled { |
| | | type boolean; |
| | | description |
| | | "RT Nbr enabled for updategento another"; |
| | | } |
| | | leaf vpn-update-gen-trigger-enabled { |
| | | type boolean; |
| | | description |
| | | "RT Nbr enabled for updategento another"; |
| | | } |
| | | leaf is-addpath-send-operational { |
| | | type boolean; |
| | | description |
| | | "Addpath is operational on send-side"; |
| | | } |
| | | leaf is-addpath-receive-operational { |
| | | type boolean; |
| | | description |
| | | "Addpath is operational on receive-side"; |
| | | } |
| | | leaf neighbor-version { |
| | | type uint32; |
| | | description |
| | | "Neighbor version"; |
| | | } |
| | | leaf weight { |
| | | type uint32; |
| | | description |
| | | "Weight for this AF"; |
| | | } |
| | | leaf max-prefix-limit { |
| | | type uint32; |
| | | description |
| | | "Max limit for # of prefixes"; |
| | | } |
| | | leaf use-max-prefix-warning-only { |
| | | type boolean; |
| | | description |
| | | "Warning only when maximum prefix limit reached"; |
| | | } |
| | | leaf max-prefix-discard-extra-paths { |
| | | type boolean; |
| | | description |
| | | "Discard extra paths when prefix limit reached"; |
| | | } |
| | | leaf max-prefix-exceed-discard-paths { |
| | | type boolean; |
| | | description |
| | | "Did we discard extra paths when prefix limit |
| | | reached"; |
| | | } |
| | | leaf max-prefix-threshold-percent { |
| | | type uint8; |
| | | units "percentage"; |
| | | description |
| | | "Percentage of maximum no. of prefixes at which |
| | | to generate warning"; |
| | | } |
| | | leaf max-prefix-restart-time { |
| | | type uint16; |
| | | units "minute"; |
| | | description |
| | | "Time interval (in minutes) after which peering |
| | | session will be reestablished"; |
| | | } |
| | | leaf prefixes-accepted { |
| | | type uint32; |
| | | description |
| | | "No. of prefixes accepted"; |
| | | } |
| | | leaf prefixes-synced { |
| | | type uint32; |
| | | description |
| | | "Number of prefixes synced to standby"; |
| | | } |
| | | leaf prefixes-withdrawn-not-found { |
| | | type uint32; |
| | | description |
| | | "No. of prefixes withdrawn but not found"; |
| | | } |
| | | leaf prefixes-denied { |
| | | type uint32; |
| | | description |
| | | "No. of prefixes denied"; |
| | | } |
| | | leaf prefixes-denied-no-policy { |
| | | type uint32; |
| | | description |
| | | "No. of prefixes denied because there was no |
| | | inbound policy"; |
| | | } |
| | | leaf prefixes-denied-rt-permit { |
| | | type uint32; |
| | | description |
| | | "No. of prefixes denied because RT extended |
| | | community is not imported"; |
| | | } |
| | | leaf prefixes-denied-orf-policy { |
| | | type uint32; |
| | | description |
| | | "No. of prefixes denied by prefix based ORF |
| | | policy"; |
| | | } |
| | | leaf prefixes-denied-policy { |
| | | type uint32; |
| | | description |
| | | "No. of prefixes denied by inbound policy"; |
| | | } |
| | | leaf number-of-bestpaths { |
| | | type uint32; |
| | | description |
| | | "No. of bestpaths from this neighbor"; |
| | | } |
| | | leaf number-of-best-externalpaths { |
| | | type uint32; |
| | | description |
| | | "No. of best-external paths from this neighbor"; |
| | | } |
| | | leaf prefixes-advertised { |
| | | type uint32; |
| | | description |
| | | "No. of prefixes advertised"; |
| | | } |
| | | leaf prefixes-be-advertised { |
| | | type uint32; |
| | | description |
| | | "No BE prefixes advertised"; |
| | | } |
| | | leaf prefixes-suppressed { |
| | | type uint32; |
| | | description |
| | | "No. of prefixes suppressed"; |
| | | } |
| | | leaf prefixes-withdrawn { |
| | | type uint32; |
| | | description |
| | | "No. of prefixes withdrawn"; |
| | | } |
| | | leaf is-peer-orf-capable { |
| | | type boolean; |
| | | description |
| | | "Peer has outbound route filter capability"; |
| | | } |
| | | leaf is-advertised-orf-send { |
| | | type boolean; |
| | | description |
| | | "Prefix based ORF send mode capability advertised"; |
| | | } |
| | | leaf is-received-orf-send-capable { |
| | | type boolean; |
| | | description |
| | | "Prefix based ORF send mode capability received"; |
| | | } |
| | | leaf is-advertised-orf-receive { |
| | | type boolean; |
| | | description |
| | | "Prefix based ORF receive mode capability |
| | | advertised"; |
| | | } |
| | | leaf is-received-orf-receive-capable { |
| | | type boolean; |
| | | description |
| | | "Prefix based ORF receive mode capability |
| | | received"; |
| | | } |
| | | leaf is-advertised-graceful-restart { |
| | | type boolean; |
| | | description |
| | | "Graceful Restart Capability advertised"; |
| | | } |
| | | leaf is-graceful-restart-state-flag { |
| | | type boolean; |
| | | description |
| | | "Restart state flag enabled"; |
| | | } |
| | | leaf is-received-graceful-restart-capable { |
| | | type boolean; |
| | | description |
| | | "Graceful Restart Capability received"; |
| | | } |
| | | leaf is-add-path-send-capability-advertised { |
| | | type boolean; |
| | | description |
| | | "Addpath Send capability advertised"; |
| | | } |
| | | leaf is-add-path-send-capability-received { |
| | | type boolean; |
| | | description |
| | | "Addpath Send capability received"; |
| | | } |
| | | leaf is-add-path-receive-capability-advertised { |
| | | type boolean; |
| | | description |
| | | "Addpath Receive capability advertised"; |
| | | } |
| | | leaf is-add-path-receive-capability-received { |
| | | type boolean; |
| | | description |
| | | "Addpath Receive capability received"; |
| | | } |
| | | leaf is-ext-nh-encoding-capability-received { |
| | | type boolean; |
| | | description |
| | | "Extended nexthop encoding capability received"; |
| | | } |
| | | leaf is-ext-nh-encoding-capability-sent { |
| | | type boolean; |
| | | description |
| | | "Extended nexhop encoding capability Sent"; |
| | | } |
| | | leaf restart-time { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Restart time advertised (seconds)"; |
| | | } |
| | | leaf local-restart-time { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Local Restart time (seconds)"; |
| | | } |
| | | leaf stale-path-timeout { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Stale path timeout time (in seconds)"; |
| | | } |
| | | leaf rib-purge-timeout-value { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "RIB purge timeout time (in seconds)"; |
| | | } |
| | | leaf neighbor-preserved-forwarding-state { |
| | | type boolean; |
| | | description |
| | | "Neighbor preserved forwarding state"; |
| | | } |
| | | leaf long-lived-graceful-restart-stale-time-configured { |
| | | type boolean; |
| | | description |
| | | "Long-lived graceful-restart stale time is |
| | | configured"; |
| | | } |
| | | leaf long-lived-graceful-restart-stale-time-sent { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Stale time sent in long-lived graceful-restart |
| | | capability (seconds)"; |
| | | } |
| | | leaf long-lived-graceful-restart-stale-time-accept { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Maximum long-lived graceful-restart stale time |
| | | acceptable from the neighbor (seconds)"; |
| | | } |
| | | leaf long-lived-graceful-restart-capability-received { |
| | | type boolean; |
| | | description |
| | | "Long-lived graceful-restart capability received |
| | | from the neighbor"; |
| | | } |
| | | leaf long-lived-graceful-restart-stale-time-received { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Long-lived graceful-restart stale time received |
| | | from the neighbor (seconds)"; |
| | | } |
| | | leaf neighbor-preserved-long-lived-forwarding-state { |
| | | type boolean; |
| | | description |
| | | "Neighbor preserved long-lived forwarding state"; |
| | | } |
| | | leaf neighbor-long-lived-graceful-restart-capable { |
| | | type boolean; |
| | | description |
| | | "Treat neighbor as long-lived graceful-restart |
| | | capable"; |
| | | } |
| | | leaf neighbor-long-lived-graceful-restart-time-remaining { |
| | | type uint32; |
| | | description |
| | | "Remaining long-lived graceful-restart time"; |
| | | } |
| | | leaf route-refreshes-received { |
| | | type uint32; |
| | | description |
| | | "Number of route refresh requests received"; |
| | | } |
| | | leaf route-refreshes-sent { |
| | | type uint32; |
| | | description |
| | | "Number of route refresh requests sent"; |
| | | } |
| | | leaf refresh-target-version { |
| | | type uint32; |
| | | description |
| | | "Target version for refresh update generation"; |
| | | } |
| | | leaf refresh-version { |
| | | type uint32; |
| | | description |
| | | "Version till which refresh updates have been |
| | | generated"; |
| | | } |
| | | leaf refresh-acked-version { |
| | | type uint32; |
| | | description |
| | | "Version acked by the peer for refresh updates |
| | | sent"; |
| | | } |
| | | leaf is-prefix-orf-present { |
| | | type boolean; |
| | | description |
| | | "Outbound route filter prefix ORF present"; |
| | | } |
| | | leaf orf-entries-received { |
| | | type uint32; |
| | | description |
| | | "Number of outbound route filter entries received"; |
| | | } |
| | | leaf is-default-originate-sent { |
| | | type boolean; |
| | | description |
| | | "Default origination update sent"; |
| | | } |
| | | leaf route-policy-prefix-orf { |
| | | type string; |
| | | description |
| | | "Prefix based ORF for incoming updates"; |
| | | } |
| | | leaf route-policy-in { |
| | | type string; |
| | | description |
| | | "Incoming route policy name"; |
| | | } |
| | | leaf route-policy-out { |
| | | type string; |
| | | description |
| | | "Outgoing route policy name"; |
| | | } |
| | | leaf route-policy-default-originate { |
| | | type string; |
| | | description |
| | | "Default-originate route policy name"; |
| | | } |
| | | leaf is-neighbor-ebgp-without-inbound-policy { |
| | | type boolean; |
| | | description |
| | | "eBGP neighbor with no configured inbound policy"; |
| | | } |
| | | leaf is-neighbor-ebgp-without-outbound-policy { |
| | | type boolean; |
| | | description |
| | | "eBGP neighbor with no configured outbound policy"; |
| | | } |
| | | leaf is-upd-orig-loopchk-disable-set { |
| | | type boolean; |
| | | description |
| | | "upd_orig_loopchk_disable set "; |
| | | } |
| | | leaf is-as-override-set { |
| | | type boolean; |
| | | description |
| | | "As override set "; |
| | | } |
| | | leaf is-allow-as-in-set { |
| | | type boolean; |
| | | description |
| | | "Allowas-in set "; |
| | | } |
| | | leaf allow-as-in-count { |
| | | type uint32; |
| | | description |
| | | "Allowas-in count config"; |
| | | } |
| | | leaf address-family-long-lived-time { |
| | | type uint32; |
| | | description |
| | | "AF specific Long-lived-time config"; |
| | | } |
| | | leaf eo-r-received-in-read-only { |
| | | type boolean; |
| | | description |
| | | "An EoR was received while in read-only mode"; |
| | | } |
| | | leaf acked-version { |
| | | type uint32; |
| | | description |
| | | "Version mapped from acked seqNo"; |
| | | } |
| | | leaf synced-acked-version { |
| | | type uint32; |
| | | description |
| | | "Version mapped from acked seqNo that was synced |
| | | last"; |
| | | } |
| | | leaf outstanding-version { |
| | | type uint32; |
| | | description |
| | | "No. of all outstanding version objects waiting |
| | | for ack from the peer"; |
| | | } |
| | | leaf outstanding-refresh-version { |
| | | type uint32; |
| | | description |
| | | "No. of only refresh version objects waiting for |
| | | ack from the peer"; |
| | | } |
| | | leaf outstanding-version-max { |
| | | type uint32; |
| | | description |
| | | "Version mapped from acked seqNo that was synced |
| | | last"; |
| | | } |
| | | leaf is-aigp-set { |
| | | type boolean; |
| | | description |
| | | "AIGP set "; |
| | | } |
| | | leaf is-rt-present { |
| | | type boolean; |
| | | description |
| | | "RT attribute list present"; |
| | | } |
| | | leaf is-rt-present-standby { |
| | | type boolean; |
| | | description |
| | | "RT attribute list present"; |
| | | } |
| | | leaf accept-own-enabled { |
| | | type boolean; |
| | | description |
| | | "Accept-Own enabled"; |
| | | } |
| | | leaf selective-multipath-eligible { |
| | | type boolean; |
| | | description |
| | | "Selective multipath eligible"; |
| | | } |
| | | leaf afrpki-disable { |
| | | type boolean; |
| | | description |
| | | "Prefix validation disabled"; |
| | | } |
| | | leaf afrpki-use-validity { |
| | | type boolean; |
| | | description |
| | | "Prefix v. use validity"; |
| | | } |
| | | leaf afrpki-allow-invalid { |
| | | type boolean; |
| | | description |
| | | "Prefix v. allow invalid"; |
| | | } |
| | | leaf afrpki-signal-ibgp { |
| | | type boolean; |
| | | description |
| | | "Prefix v. signal ibgp"; |
| | | } |
| | | leaf is-advertise-permanent-network { |
| | | type boolean; |
| | | description |
| | | "Advertise Permanent Network"; |
| | | } |
| | | leaf is-send-mcast-attr { |
| | | type boolean; |
| | | description |
| | | "Send Mcast Attr"; |
| | | } |
| | | leaf import-stitching { |
| | | type boolean; |
| | | description |
| | | "Import Stitching enabled"; |
| | | } |
| | | leaf import-reoriginate { |
| | | type boolean; |
| | | description |
| | | "Import Reoriginate enabled"; |
| | | } |
| | | leaf import-reoriginate-stitching { |
| | | type boolean; |
| | | description |
| | | "Import Reoriginate Stitching enabled"; |
| | | } |
| | | leaf advertise-v4-flags { |
| | | type uint32; |
| | | description |
| | | "Advertise options for VPNV4"; |
| | | } |
| | | leaf advertise-v6-flags { |
| | | type uint32; |
| | | description |
| | | "Advertise options for VPNV6"; |
| | | } |
| | | leaf advertise-local-labeled-route-unicast { |
| | | type boolean; |
| | | description |
| | | "Advertise routes with "; |
| | | } |
| | | leaf prefixes-denied-non-cumulative { |
| | | type uint32; |
| | | description |
| | | "No. of prefixes exactly denied (non cumulative)"; |
| | | } |
| | | leaf enable-label-stack { |
| | | type boolean; |
| | | description |
| | | "Enable label stack"; |
| | | } |
| | | list extended-community { |
| | | description |
| | | "Extended community attribute"; |
| | | leaf entry { |
| | | type uint8; |
| description | | description |
| "Tbl Id "; | | "Extended community attribute"; |
| | | } |
| | | } |
| | | list extended-community-standby { |
| | | description |
| | | "Extended community attribute"; |
| | | leaf entry { |
| | | type uint8; |
| | | description |
| | | "Extended community attribute"; |
| | | } |
| | | } |
| | | } |
| | | |
| | | grouping BGP-PERF-NBR { |
| | | description |
| | | "BGP PERF NBR"; |
| | | leaf read-throttles { |
| | | type uint32; |
| | | description |
| | | "Number of partial read throttles"; |
| | | } |
| | | leaf low-throttled-read { |
| | | type uint32; |
| | | description |
| | | "Num socket reads after nbrs crossed low |
| | | threshold"; |
| | | } |
| | | leaf high-throttled-read { |
| | | type uint32; |
| | | description |
| | | "Num of socket reads after nbr crossed high |
| | | threshold"; |
| | | } |
| | | leaf time-since-last-throttled-read { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time (in secs) since last read after being |
| | | throttled"; |
| | | } |
| | | leaf read-calls-count { |
| | | type uint32; |
| | | description |
| | | "No. of calls to function to read inbound data"; |
| | | } |
| | | leaf read-messages-count { |
| | | type uint32; |
| | | description |
| | | "Number of BGP messages read"; |
| | | } |
| | | leaf data-bytes-read { |
| | | type uint32; |
| | | units "byte"; |
| | | description |
| | | "No. of bytes of data read"; |
| | | } |
| | | leaf io-read-time { |
| | | type uint32; |
| | | units "millisecond"; |
| | | description |
| | | "Time spent reading inbound data (milliseconds)"; |
| | | } |
| | | leaf write-calls-count { |
| | | type uint32; |
| | | description |
| | | "No. of calls to function to write outbound data"; |
| | | } |
| | | leaf data-bytes-written { |
| | | type uint32; |
| | | units "byte"; |
| | | description |
| | | "No. of data bytes written"; |
| | | } |
| | | leaf io-write-time { |
| | | type uint32; |
| | | units "millisecond"; |
| | | description |
| | | "Time spent writing outbound data (milliseconds)"; |
| | | } |
| | | leaf last-sent-seq-no { |
| | | type uint32; |
| | | description |
| | | "Seq No of the last sent byte"; |
| | | } |
| | | leaf write-subgroup-calls-count { |
| | | type uint32; |
| | | description |
| | | "No. of calls to function to process sub-group |
| | | message list"; |
| | | } |
| | | leaf write-subgroup-messages-count { |
| | | type uint32; |
| | | description |
| | | "Number of sub-group msgs processed"; |
| | | } |
| | | leaf subgroup-list-time { |
| | | type uint32; |
| | | units "millisecond"; |
| | | description |
| | | "Time spent processing sub-group message list |
| | | (milliseconds)"; |
| | | } |
| | | leaf write-queue-calls-count { |
| | | type uint32; |
| | | description |
| | | "No. of calls to function to process write queue"; |
| | | } |
| | | leaf write-queue-messages-count { |
| | | type uint32; |
| | | description |
| | | "Number of write queue messages processed"; |
| | | } |
| | | leaf write-queue-time { |
| | | type uint32; |
| | | units "millisecond"; |
| | | description |
| | | "Time spent processing write queue (milliseconds)"; |
| | | } |
| | | leaf inbound-update-messages { |
| | | type uint32; |
| | | description |
| | | "Number of inbound update messages processed"; |
| | | } |
| | | leaf inbound-update-messages-time { |
| | | type uint32; |
| | | units "millisecond"; |
| | | description |
| | | "Time spent processing inbound update messages |
| | | (milliseconds)"; |
| | | } |
| | | leaf maximum-read-size { |
| | | type uint32; |
| | | units "millisecond"; |
| | | description |
| | | "Size of largest socket (milliseconds)"; |
| | | } |
| | | leaf actives { |
| | | type uint32; |
| | | description |
| | | "Number of retried Active opens for this neighbor"; |
| | | } |
| | | leaf failed-post-actives { |
| | | type uint32; |
| | | description |
| | | "Number of Active Opens that failed in the Post |
| | | Active State for this neighbor"; |
| | | } |
| | | leaf passives { |
| | | type uint32; |
| | | description |
| | | "Number of retried Passive opens for this |
| | | neighbor"; |
| | | } |
| | | leaf rejected-passives { |
| | | type uint32; |
| | | description |
| | | "Number of rejected Passive opens for this |
| | | neighbor"; |
| | | } |
| | | leaf active-collision { |
| | | type uint32; |
| | | description |
| | | "Number of Closed Active connections for this |
| | | neighbor due to collision "; |
| | | } |
| | | leaf passive-collision { |
| | | type uint32; |
| | | description |
| | | "Number of Closed Remote opens for this |
| | | neighborneighbor due to collision "; |
| | | } |
| | | leaf control-to-read-thread-trigger { |
| | | type uint32; |
| | | description |
| | | "Number of times io-control thread trigger read |
| | | thread"; |
| | | } |
| | | leaf control-to-write-thread-trigger { |
| | | type uint32; |
| | | description |
| | | "Number of times io-control thread trigger write |
| | | thread"; |
| | | } |
| | | leaf network-status { |
| | | type uint32; |
| | | description |
| | | "Socket status, TRUE if socket closed"; |
| | | } |
| | | leaf reset-flags { |
| | | type uint32; |
| | | description |
| | | "Reset flags, per thread"; |
| | | } |
| | | leaf nbr-flags { |
| | | type uint32; |
| | | description |
| | | "Nbr flags, per thread"; |
| | | } |
| | | leaf nbr-fd { |
| | | type int32; |
| | | description |
| | | "Primary FD, per nbr"; |
| | | } |
| | | leaf reset-retries { |
| | | type uint8; |
| | | description |
| | | "Reset Retries, per nbr"; |
| | | } |
| | | leaf sync-flags { |
| | | type uint32; |
| | | description |
| | | "Sync flags, per nbr"; |
| | | } |
| | | leaf nsr-oper-down-count { |
| | | type uint32; |
| | | description |
| | | "Number of times NSR scoped sync has been done"; |
| | | } |
| | | leaf last-nsr-scoped-sync { |
| | | type uint32; |
| | | description |
| | | "Last time NSR scoped syncwas done for the |
| | | neighbor"; |
| | | } |
| | | } |
| | | |
| | | grouping BGP-NOTFNTYPE { |
| | | description |
| | | "BGP NOTFNTYPE"; |
| | | leaf time-since-last-notification { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time since the last notification was sent or |
| | | received (seconds)"; |
| | | } |
| | | leaf notification-error-code { |
| | | type uint8; |
| | | description |
| | | "Error code in last notification"; |
| | | } |
| | | leaf notification-error-subcode { |
| | | type uint8; |
| | | description |
| | | "Error subcode in last notification"; |
| | | } |
| | | list last-notification-data { |
| | | description |
| | | "Message data in last notification"; |
| | | leaf entry { |
| | | type uint8; |
| | | description |
| | | "Message data in last notification"; |
| | | } |
| | | } |
| | | } |
| | | |
| | | grouping BGP-NBR-BAG { |
| | | description |
| | | "BGP Neighbor Information"; |
| | | container connection-local-address { |
| | | description |
| | | "Local address for the connection"; |
| | | uses BGP-ADDRTYPE; |
| | | } |
| | | container connection-remote-address { |
| | | description |
| | | "Remote address for the connection"; |
| | | uses BGP-ADDRTYPE; |
| | | } |
| | | container send-notification-info { |
| | | description |
| | | "Information on the last notification sent"; |
| | | uses BGP-NOTFNTYPE; |
| | | } |
| | | container received-notification-info { |
| | | description |
| | | "Information on the last notification received"; |
| | | uses BGP-NOTFNTYPE; |
| | | } |
| | | container performance-statistics { |
| | | description |
| | | "Performance statistics"; |
| | | uses BGP-PERF-NBR; |
| | | } |
| | | container message-statistics { |
| | | description |
| | | "Message statistics"; |
| | | uses BGP-NBR-MSG-STATS; |
| | | } |
| | | container tcp-init-sync-time-spec { |
| | | description |
| | | "Time When neighbor entered TCP Init Sync"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container tcp-init-sync-phase-two-time-spec { |
| | | description |
| | | "Time when neighbor entered TCP Init Sync Phase |
| | | Two"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container tcp-init-sync-done-time-spec { |
| | | description |
| | | "Time when neighbor entered TCP Init Sync Done"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container graceful-maintenance { |
| | | description |
| | | "Graceful Maintenance"; |
| | | uses BGP-NBR-GSHUT; |
| | | } |
| | | leaf speaker-id { |
| | | type uint8; |
| | | description |
| | | "Speaker this neighbor is allocated to"; |
| | | } |
| | | leaf description { |
| | | type string; |
| | | description |
| | | "Description"; |
| | | } |
| | | leaf local-as { |
| | | type uint32; |
| | | description |
| | | "Local AS number"; |
| | | } |
| | | leaf remote-as { |
| | | type uint32; |
| | | description |
| | | "Remote AS number"; |
| | | } |
| | | leaf has-internal-link { |
| | | type boolean; |
| | | description |
| | | "Internal link to neighbor"; |
| | | } |
| | | leaf is-external-neighbor-not-directly-connected { |
| | | type boolean; |
| | | description |
| | | "External neighbor not directly connected"; |
| | | } |
| | | leaf messages-received { |
| | | type uint32; |
| | | description |
| | | "Number of messages received"; |
| | | } |
| | | leaf messages-sent { |
| | | type uint32; |
| | | description |
| | | "Number of messages sent"; |
| | | } |
| | | leaf update-messages-in { |
| | | type uint32; |
| | | description |
| | | "No. of update msgs received"; |
| | | } |
| | | leaf update-messages-out { |
| | | type uint32; |
| | | description |
| | | "No. of update messages sent"; |
| | | } |
| | | leaf messages-queued-in { |
| | | type uint32; |
| | | description |
| | | "No. of msgs on receive queue"; |
| | | } |
| | | leaf messages-queued-out { |
| | | type uint32; |
| | | description |
| | | "No. of messages on send queue"; |
| | | } |
| | | leaf connection-established-time { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time (in secs) that the connection has been |
| | | established"; |
| | | } |
| | | leaf connection-state { |
| | | type Bgp-conn-state; |
| | | description |
| | | "State of connection"; |
| | | } |
| | | leaf previous-connection-state { |
| | | type uint32; |
| | | description |
| | | "Previous state of connection"; |
| | | } |
| | | leaf connection-admin-status { |
| | | type uint32; |
| | | description |
| | | "Administrative status of connection"; |
| | | } |
| | | leaf open-check-error-code { |
| | | type Bgp-open-check-err; |
| | | description |
| | | "Open check error code"; |
| | | } |
| | | leaf is-local-address-configured { |
| | | type boolean; |
| | | description |
| | | "Local address configured for the neighbor |
| | | connection"; |
| | | } |
| | | leaf connection-local-port { |
| | | type uint32; |
| | | description |
| | | "Local port for the connection"; |
| | | } |
| | | leaf connection-remote-port { |
| | | type uint32; |
| | | description |
| | | "Remote port for the connection"; |
| | | } |
| | | leaf neighbor-interface-handle { |
| | | type uint32; |
| | | description |
| | | "Interface Handle of Neighbor"; |
| | | } |
| | | leaf reset-notification-sent { |
| | | type boolean; |
| | | description |
| | | "Notification was sent during last reset"; |
| | | } |
| | | leaf is-administratively-shut-down { |
| | | type boolean; |
| | | description |
| | | "Neighbor is administratively shut down"; |
| | | } |
| | | leaf is-neighbor-max-prefix-shutdown { |
| | | type boolean; |
| | | description |
| | | "Neighbor shut down because it exceeded max prfx |
| | | count"; |
| | | } |
| | | leaf is-out-of-memory-shutdown { |
| | | type boolean; |
| | | description |
| | | "Neighbor shut down during a SEVERE low memory |
| | | condition"; |
| | | } |
| | | leaf is-out-of-memory-forced-up { |
| | | type boolean; |
| | | description |
| | | "Neighbor forced up during a low memory condition"; |
| | | } |
| | | leaf is-ebgp-peer-as-league { |
| | | type boolean; |
| | | description |
| | | "EBGP peer belongs to AS League"; |
| | | } |
| | | leaf is-ebgp-peer-common-admin { |
| | | type boolean; |
| | | description |
| | | "EBGP peer with common administation"; |
| | | } |
| | | leaf ttl-security-enabled { |
| | | type boolean; |
| | | description |
| | | "TTL Security enabled"; |
| | | } |
| | | leaf suppress4-byte-as { |
| | | type boolean; |
| | | description |
| | | "Suppress 4byteas capability"; |
| | | } |
| | | leaf bfd-session-state { |
| | | type Bgp-bfd-state; |
| | | description |
| | | "BFD state for this peer"; |
| | | } |
| | | leaf bfd-session-created-state { |
| | | type Bgp-bfd-state; |
| | | description |
| | | "BFD state for this peer"; |
| | | } |
| | | leaf bfd-session-enable-mode { |
| | | type Bgp-bfd-enable-mode; |
| | | description |
| | | "BFD enable mode for this peer"; |
| | | } |
| | | leaf bfd-minintervalval { |
| | | type uint32; |
| | | description |
| | | "BFD Mininterval for this peer"; |
| | | } |
| | | leaf bfd-multiplierval { |
| | | type uint32; |
| | | description |
| | | "BFD Multiplier for this peer"; |
| | | } |
| | | leaf bfd-state-ts { |
| | | type uint64; |
| | | description |
| | | "Timestamp since when nbr is in this bfd state"; |
| | | } |
| | | leaf router-id { |
| | | type inet:ipv4-address; |
| | | description |
| | | "Router ID for the neighbor"; |
| | | } |
| | | leaf negotiated-protocol-version { |
| | | type uint16; |
| | | description |
| | | "Negotiated protocol version"; |
| | | } |
| | | leaf ebgp-time-to-live { |
| | | type uint32; |
| | | description |
| | | "Maximum number of hops for external BGP neighbor"; |
| | | } |
| | | leaf is-ebgp-multihop-bgp-mpls-forwarding-disabled { |
| | | type boolean; |
| | | description |
| | | "If true, MPLS and NULL rewrite is disabled; if |
| | | false, it is enabled"; |
| | | } |
| | | leaf tcpmss { |
| | | type uint32; |
| | | description |
| | | "Neighbor TCP Maximum Segment |
| | | size"; |
| | | } |
| | | leaf msg-log-in { |
| | | type uint32; |
| | | description |
| | | "Message in log count"; |
| | | } |
| | | leaf msg-log-out { |
| | | type uint32; |
| | | description |
| | | "Message out log count"; |
| | | } |
| | | leaf neighbor-local-as { |
| | | type uint32; |
| | | description |
| | | "Local AS configured on the neighbor"; |
| | | } |
| | | leaf local-as-no-prepend { |
| | | type boolean; |
| | | description |
| | | "Option to not prepend the Local AS to |
| | | announcements"; |
| | | } |
| | | leaf is-capability-negotiation-suppressed { |
| | | type boolean; |
| | | description |
| | | "Capability negotiation suppressed"; |
| | | } |
| | | leaf is-capability-negotiation-performed { |
| | | type boolean; |
| | | description |
| | | "Capability negotiation performed"; |
| | | } |
| | | leaf is-route-refresh-capability-received { |
| | | type boolean; |
| | | description |
| | | "Route refresh capability received"; |
| | | } |
| | | leaf is-route-refresh-old-capability-received { |
| | | type boolean; |
| | | description |
| | | "Route refresh old capability received"; |
| | | } |
| | | leaf is-gr-aware { |
| | | type boolean; |
| | | description |
| | | "GR awareness received"; |
| | | } |
| | | leaf is4-byte-as-capability-received { |
| | | type boolean; |
| | | description |
| | | "4-byte AScapability received"; |
| | | } |
| | | leaf is4-byte-as-capability-sent { |
| | | type boolean; |
| | | description |
| | | "4-byte AScapability Snt"; |
| | | } |
| | | leaf multi-protocol-capability-received { |
| | | type boolean; |
| | | description |
| | | "Multi-protocol capability has been received"; |
| | | } |
| | | leaf hold-time { |
| | | type uint16; |
| | | units "second"; |
| | | description |
| | | "Hold time (in secs) negotiated for this |
| | | connection"; |
| | | } |
| | | leaf keep-alive-time { |
| | | type uint16; |
| | | units "second"; |
| | | description |
| | | "Keepalive time (in secs) negotiated for this |
| | | connection"; |
| | | } |
| | | leaf configured-hold-time { |
| | | type uint16; |
| | | units "second"; |
| | | description |
| | | "Hold time (in secs) configured for this |
| | | connection"; |
| | | } |
| | | leaf configured-keepalive { |
| | | type uint16; |
| | | units "second"; |
| | | description |
| | | "Keepalive time (in secs) configured for this |
| | | connection"; |
| | | } |
| | | leaf configured-min-acc-hold-time { |
| | | type uint16; |
| | | units "second"; |
| | | description |
| | | "Minimum acceptable hold time from neighbor (in |
| | | secs) configured for this connection"; |
| | | } |
| | | leaf min-advertise-interval { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Minimum advertisement interval, secs part"; |
| | | } |
| | | leaf min-advertise-interval-msecs { |
| | | type uint32; |
| | | units "millisecond"; |
| | | description |
| | | "Minimum advertisement interval, msecs part"; |
| | | } |
| | | leaf min-origination-interval { |
| | | type uint16; |
| | | units "second"; |
| | | description |
| | | "Minimum origination interval (in secs)"; |
| | | } |
| | | leaf connect-retry-interval { |
| | | type uint16; |
| | | units "second"; |
| | | description |
| | | "Time (in secs) for connect retry timer"; |
| | | } |
| | | leaf time-since-last-update { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time (in secs) since last update message was |
| | | received"; |
| | | } |
| | | leaf time-since-last-read { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time (in secs) since last read"; |
| | | } |
| | | leaf time-since-last-read-reset { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time (in secs) since last read before last reset"; |
| | | } |
| | | leaf time-last-cb { |
| | | type uint64; |
| | | description |
| | | "CB"; |
| | | } |
| | | leaf time-last-cb-reset { |
| | | type uint32; |
| | | description |
| | | "Last CB before reset"; |
| | | } |
| | | leaf time-last-fb { |
| | | type uint64; |
| | | description |
| | | "FB"; |
| | | } |
| | | leaf count-last-write { |
| | | type uint32; |
| | | description |
| | | "Count"; |
| | | } |
| | | leaf time-since-last-write { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time (in secs) since last write"; |
| | | } |
| | | leaf attempted-last-write-bytes { |
| | | type uint32; |
| | | description |
| | | "Attempted size of last write"; |
| | | } |
| | | leaf actual-last-write-bytes { |
| | | type uint32; |
| | | description |
| | | "Actual size of last write"; |
| | | } |
| | | leaf time-since-second-last-write { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time (in secs) since second last write"; |
| | | } |
| | | leaf attempted-second-last-write-bytes { |
| | | type uint32; |
| | | description |
| | | "Attempted size of second last write"; |
| | | } |
| | | leaf actual-second-last-write-bytes { |
| | | type uint32; |
| | | description |
| | | "Actual size of second last write"; |
| | | } |
| | | leaf time-since-last-write-reset { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time (in secs) since last write before last |
| | | reset"; |
| | | } |
| | | leaf attempted-last-write-reset-bytes { |
| | | type uint32; |
| | | description |
| | | "Attempted size of last write before reset"; |
| | | } |
| | | leaf actual-last-write-reset-bytes { |
| | | type uint32; |
| | | description |
| | | "Actual size of last write before reset"; |
| | | } |
| | | leaf time-since-second-last-write-reset { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time (in secs) since last write before last |
| | | reset"; |
| | | } |
| | | leaf attempted-second-last-write-reset-bytes { |
| | | type uint32; |
| | | description |
| | | "Attempted size of second last write before reset"; |
| | | } |
| | | leaf actual-second-last-write-reset-bytes { |
| | | type uint32; |
| | | description |
| | | "Actual size of second last write before reset"; |
| | | } |
| | | leaf last-write-event { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time (in secs) since last write thread event"; |
| | | } |
| | | leaf second-last-write-event { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time (in secs) since second last write thread |
| | | event"; |
| | | } |
| | | leaf last-k-aexpiry-reset { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time (in secs) since last KA timer expiry before |
| | | reset"; |
| | | } |
| | | leaf second-last-k-aexpiry-reset { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time (in secs) since second last KA timer expiry |
| | | before reset"; |
| | | } |
| | | leaf last-k-anotsent-reset { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Duration (in secs) since last time that KA was |
| | | not sent before reset"; |
| | | } |
| | | leaf last-k-aerror-reset { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Duration (in secs) since last time that an error |
| | | was encountered after KA expiry"; |
| | | } |
| | | leaf last-k-astart-reset { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time (in secs) since the last KA timer start |
| | | before reset"; |
| | | } |
| | | leaf second-last-k-astart-reset { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time (in secs) since the second last KA timer |
| | | start before reset"; |
| | | } |
| | | leaf connection-up-count { |
| | | type uint32; |
| | | description |
| | | "Number of times the connection was established"; |
| | | } |
| | | leaf connection-down-count { |
| | | type uint32; |
| | | description |
| | | "Number of times connection was dropped"; |
| | | } |
| | | leaf time-since-connection-last-dropped { |
| | | type uint32; |
| | | units "second"; |
| | | description |
| | | "Time since the connection last went down |
| | | (seconds)"; |
| | | } |
| | | leaf reset-reason { |
| | | type Bgp-reset-reason-index; |
| | | description |
| | | "Reason for last connection reset"; |
| | | } |
| | | leaf peer-reset-reason { |
| | | type Bgp-peer-reset-reason-index; |
| | | description |
| | | "Reason for last peer close event"; |
| | | } |
| | | leaf peer-error-code { |
| | | type uint32; |
| | | description |
| | | "If peer closed, error received from transport"; |
| | | } |
| | | leaf last-notify-error-code { |
| | | type uint8; |
| | | description |
| | | "Code for the last error notification seen on the |
| | | connection"; |
| | | } |
| | | leaf last-notify-error-subcode { |
| | | type uint8; |
| | | description |
| | | "Error subcode of the last error notification |
| | | seen on the connection"; |
| | | } |
| | | leaf error-notifies-received { |
| | | type uint32; |
| | | description |
| | | "Number of error notifications received on the |
| | | connection"; |
| | | } |
| | | leaf error-notifies-sent { |
| | | type uint32; |
| | | description |
| | | "Number of error notifications sent on the |
| | | connection"; |
| | | } |
| | | leaf remote-as-number { |
| | | type uint32; |
| | | description |
| | | "Remote AS number"; |
| | | } |
| | | leaf dmz-link-bandwidth { |
| | | type uint32; |
| | | description |
| | | "Bandwidth of link to single-hop eBGP peer"; |
| | | } |
| | | leaf ebgp-recv-dmz { |
| | | type boolean; |
| | | description |
| | | "Receive Bandwidth of link to single-hop eBGP |
| | | peer"; |
| | | } |
| | | leaf ebgp-send-dmz-mode { |
| | | type Bgp-ebgp-send-dmz-enable-mode; |
| | | description |
| | | "Ebgp send dmz link bw mode"; |
| | | } |
| | | leaf tos-type { |
| | | type uint8; |
| | | description |
| | | "Precedence or DSCP type"; |
| | | } |
| | | leaf tos-value { |
| | | type uint8; |
| | | description |
| | | "Precedence or DSCP value"; |
| | | } |
| | | leaf tcp-session-open-mode { |
| | | type Bgp-tcp-mode; |
| | | description |
| | | "The TCP mode to be used to set up BGP session |
| | | with the neighbor"; |
| } | | } |
| leaf vrf-name { | | leaf vrf-name { |
| type string; | | type string; |
| description | | description |
| "Name of the VRF"; | | "Name of the VRF"; |
| } | | } |
| n | } | n | leaf standby-rp { |
| | | type boolean; |
| grouping BGP-DEP-BAG { | | |
| description | | description |
| "BGP SVD"; | | "Standby RP socket inited for Active Open"; |
| list dep-entry-info { | | |
| description | | |
| "List of Dependency Tables "; | | |
| uses BGP-DEP-ENTRY-INFO; | | |
| } | | |
| } | | } |
| | | leaf nsr-enabled { |
| grouping BGP-UPDGEN-AF-BAG { | | type boolean; |
| description | | description |
| "BGP Update generation address-family information"; | | "Neighbor supports NSR"; |
| container update-statistics { | | |
| description | | |
| "BGP address-family statistics update"; | | |
| uses BGP-UPDGEN-STATS-BAG; | | |
| } | | } |
| n | leaf update-group-af-name { | n | leaf graceful-restart-enabled-nbr { |
| type Bgp-afi; | | type boolean; |
| description | | description |
| n | "Address family identifier"; | n | "Neighbor supports graceful-restart"; |
| } | | } |
| n | leaf update-main-table-version { | n | leaf gr-restart-time { |
| type uint64; | | type uint32; |
| | | units "second"; |
| description | | description |
| n | "Main table version"; | n | "Neighbor restart time (in seconds)"; |
| } | | } |
| n | leaf update-rib-version { | n | leaf gr-stale-path-time { |
| type uint64; | | type uint32; |
| | | units "second"; |
| description | | description |
| n | "RIB version"; | n | "Neighbor stale-path time (in seconds)"; |
| } | | } |
| n | leaf update-min-neighbor-version { | n | leaf fssn-offset { |
| type uint64; | | type uint32; |
| description | | description |
| n | "Minimum Neighbor version"; | n | "First standby SeqNo offset"; |
| } | | } |
| n | leaf current-update-limit-af { | n | leaf fpbsn-offset { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP Current AF sub-group update limit"; | n | "First standby PDU boundary SeqNo offset"; |
| } | | } |
| n | leaf configured-update-limit-af { | n | leaf last-ackd-seq-no { |
| | | type uint32; |
| | | description |
| | | "SeqNo of the last Ackd byte"; |
| | | } |
| | | leaf bytes-written { |
| type uint32; | | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| n | "Update limit per address-family in bytes"; | n | "Total bytes written by write thread"; |
| } | | } |
| n | leaf current-update-limit-subgrp-ebgp { | n | leaf bytes-read { |
| type uint32; | | |
| description | | |
| "Current EBGP sub-group update limit"; | | |
| } | | |
| leaf configured-update-limit-subgrp-ebgp { | | |
| type uint32; | | |
| description | | |
| "Configured EBGP sub-group update limit"; | | |
| } | | |
| leaf current-update-limit-sub-group-ibgp { | | |
| type uint32; | | |
| description | | |
| "Current IBGP sub-group update limit"; | | |
| } | | |
| leaf configured-update-limit-sub-group-ibgp { | | |
| type uint32; | | |
| description | | |
| "Configured IBGP sub-group update limit"; | | |
| } | | |
| leaf update-out-queue-messages { | | |
| type uint32; | | |
| description | | |
| "OutQueue messsages"; | | |
| } | | |
| leaf update-out-queue-size { | | |
| type uint32; | | |
| description | | |
| "OutQueue size"; | | |
| } | | |
| leaf update-throttled { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if update generation is | | |
| currently throttled"; | | |
| } | | |
| leaf update-update-group-count { | | |
| type uint32; | | |
| description | | |
| "Update-group count"; | | |
| } | | |
| leaf update-sub-group-count { | | |
| type uint32; | | |
| description | | |
| "Sub-group count"; | | |
| } | | |
| leaf sub-group-throttled-count { | | |
| type uint32; | | |
| description | | |
| "Throttled sub-group count"; | | |
| } | | |
| leaf refresh-sub-group-count { | | |
| type uint32; | | |
| description | | |
| "Number of refresh sub groups"; | | |
| } | | |
| leaf refresh-sub-group-throttled-count { | | |
| type uint32; | | |
| description | | |
| "Throttled refresh sub-group count"; | | |
| } | | |
| leaf filter-group-count { | | |
| type uint32; | | |
| description | | |
| "Number of refresh filter groups"; | | |
| } | | |
| leaf neighbor-count { | | |
| type uint32; | | |
| description | | |
| "Number of neighbors in BGP"; | | |
| } | | |
| leaf update-table-vrf-name { | | |
| type string; | | |
| description | | |
| "VRF Name"; | | |
| } | | |
| leaf update-vrfaf-name { | | |
| type uint32; | | |
| description | | |
| "Address family identifier"; | | |
| } | | |
| leaf update-vrf-rd-version { | | |
| type uint64; | | type uint32; |
| description | | units "byte"; |
| "RD Version"; | | |
| } | | |
| leaf update-vrf-table-rib-version { | | |
| type uint64; | | |
| description | | |
| "VRF Table RIB version"; | | |
| } | | |
| leaf table-inter-afi-import-advertise { | | |
| type boolean; | | |
| description | | |
| "InterAfi Import Advertise"; | | |
| } | | |
| leaf table-inter-afi-export-allow-imported-vpn { | | |
| type boolean; | | |
| description | | |
| "InterAfi Export Allow Imported VPN"; | | |
| } | | |
| leaf export-allow-imported-vpn { | | |
| type boolean; | | |
| description | | |
| "Export Allow Imported VPN"; | | |
| } | | |
| leaf vrf-import-advertise { | | |
| type boolean; | | |
| description | | |
| "Vrf Import Advertise"; | | |
| } | | |
| leaf table-update-group-count { | | |
| type uint32; | | |
| description | | |
| "Number of virtual routing and forwarding table | | |
| update groups"; | | |
| } | | |
| leaf update-table-sub-group-count { | | |
| type uint32; | | |
| description | | |
| "Number of virtual routing and forwarding table | | |
| sub groups"; | | |
| } | | |
| leaf table-sub-group-throttled-count { | | |
| type uint32; | | |
| description | | |
| "VRF Table throttled sub-group count"; | | |
| } | | |
| leaf table-refresh-sub-group-count { | | |
| type uint32; | | |
| description | | |
| "Number of virtual routing and forwarding table | | |
| refresh sub groups"; | | |
| } | | |
| leaf table-refresh-sub-group-throttled-count { | | |
| type uint32; | | |
| description | | |
| "VRF Table throttled refresh sub-group count"; | | |
| } | | |
| leaf update-table-filter-group-count { | | |
| type uint32; | | |
| description | | |
| "Number of virtual routing and forwarding table | | |
| filter groups"; | | |
| } | | |
| leaf table-neighbor-count { | | |
| type uint32; | | |
| description | | |
| "Number of virtual routing and forwarding table | | |
| neighbors"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-SLOW-PEER-VER-BAG { | | |
| description | | description |
| "BGP Slow peer version information"; | | "Total bytes read"; |
| leaf slow-peer-start-version { | | } |
| | | leaf socket-read-bytes { |
| type uint64; | | type uint32; |
| description | | units "byte"; |
| "Slow Peer Start Version"; | | |
| } | | |
| leaf slow-peer-end-version { | | |
| type uint64; | | |
| description | | |
| "Slow Peer End Version"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-UPDGEN-NBR-BAG { | | |
| description | | description |
| "BGP Update generation Neighbor information"; | | "Total read bytes value insocket-lib"; |
| container update-neighbor-address { | | } |
| | | leaf is-read-disabled { |
| | | type boolean; |
| | | description |
| | | "If true, socket read isdisabled"; |
| | | } |
| | | leaf update-bytes-read { |
| | | type uint32; |
| | | units "byte"; |
| | | description |
| | | "Total update bytes read"; |
| | | } |
| | | leaf nsr-state { |
| | | type Bgp-sync-nbr-nsr-state; |
| | | description |
| | | "NSR state"; |
| | | } |
| | | leaf is-passive-close { |
| | | type boolean; |
| | | description |
| | | "If true, active socket canbe closed if passive |
| | | openis received for a GRcapable neighbor"; |
| | | } |
| | | leaf nbr-enforce-first-as { |
| | | type boolean; |
| | | description |
| | | "Neighbor enforce first AS"; |
| | | } |
| | | leaf active-bmp-servers { |
| | | type uint8; |
| | | description |
| | | "BMP Servers to which the neighbor sends logs"; |
| | | } |
| | | leaf nbr-cluster-id { |
| | | type uint32; |
| | | description |
| | | "Cluster id"; |
| | | } |
| | | leaf nbr-in-cluster { |
| | | type uint8; |
| | | description |
| | | "Type of cluster_id:undefined/number/Ip address"; |
| | | } |
| | | leaf ignore-connected { |
| | | type boolean; |
| | | description |
| | | "If true, the VPN client isan IBGP CE peer"; |
| | | } |
| | | leaf internal-vpn-client { |
| | | type boolean; |
| | | description |
| | | "If true, don't do NHconnected check for nbr"; |
| | | } |
| | | leaf io-armed { |
| | | type boolean; |
| | | description |
| | | "If true, socket has beenauto-armed for io |
| | | control"; |
| | | } |
| | | leaf read-armed { |
| | | type boolean; |
| | | description |
| | | "If true, socket has beenauto-armed for read"; |
| | | } |
| | | leaf write-armed { |
| | | type boolean; |
| | | description |
| | | "If true, socket has beenauto-armed for write"; |
| | | } |
| | | leaf discard-data-bytes { |
| | | type uint32; |
| | | units "byte"; |
| | | description |
| | | "Remaining discard data (bytes) on Standby"; |
| | | } |
| | | leaf local-as-replace-as { |
| | | type boolean; |
| | | description |
| | | "Local AS Replace-AS option"; |
| | | } |
| | | leaf local-as-dual-as { |
| | | type boolean; |
| | | description |
| | | "Local AS Dual-AS option"; |
| | | } |
| | | leaf local-as-dual-as-mode-native { |
| | | type boolean; |
| | | description |
| | | "Applies only if Local AS Dual-AS option is |
| | | enabled. Indicates if Dual-AS mode is native."; |
| | | } |
| | | leaf egress-peer-engineering-enabled { |
| | | type boolean; |
| | | description |
| | | "Indicates if Egress Peer Engineering is enabled"; |
| | | } |
| | | leaf discard-as4-path { |
| | | type uint32; |
| | | description |
| | | "Discard AS4_PATH in case there is a discrepancy |
| | | in merging AS_PATH and AS4_PATH,retain ASPATH"; |
| | | } |
| | | leaf rpki-disable { |
| | | type boolean; |
| | | description |
| | | "Prefix validation disabled"; |
| | | } |
| | | leaf rpki-use-validity { |
| | | type boolean; |
| | | description |
| | | "Prefix v. use validity"; |
| | | } |
| | | leaf rpki-allow-invalid { |
| | | type boolean; |
| | | description |
| | | "Prefix v. allow invalid"; |
| | | } |
| | | leaf rpki-signal-ibgp { |
| | | type boolean; |
| | | description |
| | | "Prefix v. signal ibgp"; |
| | | } |
| | | leaf dynamic-neighbor { |
| | | type boolean; |
| | | description |
| | | "Dynamic neighbor"; |
| | | } |
| | | leaf merge-inbound-safi1and4-updates { |
| | | type boolean; |
| | | description |
| | | "Merge SAFI-1 and SAFI-4 updates from neighbor"; |
| | | } |
| | | list af-data { |
| | | max-elements "25"; |
| | | description |
| | | "Address family specific neighbor data"; |
| | | uses BGP-NBR-AF; |
| | | } |
| | | } |
| | | |
| | | grouping BGP-PATH-MULTI { |
| description | | description |
| | | "BGP path set"; |
| | | list paths { |
| | | description |
| | | "paths"; |
| | | uses BGP-PATH-BAG; |
| | | } |
| | | list adv-path-info { |
| | | description |
| | | "Net Advertized Paths"; |
| | | uses BGP-PATH-ADV-BAG; |
| | | } |
| | | } |
| | | |
| | | grouping BGP-NBR-ADV-CNT-BAG { |
| | | description |
| | | "BGP Neighbor adv cnt bag"; |
| | | leaf max-prefix-advertisedcount { |
| | | type uint32; |
| | | description |
| | | "Number of prefixes advertsied to neighbor"; |
| | | } |
| | | } |
| | | |
| | | grouping BGP-EPE-SET-BAG { |
| | | description |
| | | "BGP EPE SET BAG"; |
| | | container epe-local-address { |
| | | description |
| "Neighbor address"; | | "Local address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| n | container last-sub-group-add-timestamp { | n | container epe-next-hop { |
| description | | |
| "Last added time"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container last-sub-group-remove-timestamp { | | |
| description | | |
| "Last removed time"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container last-filter-group-add-timestamp { | | |
| description | | |
| "Last added time"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container last-filter-group-remove-timestamp { | | |
| description | | |
| "Last removed time"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container first-default-originate-timestamp { | | |
| description | | |
| "Timestamp when the first default-origination was | | |
| done"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container last-default-originate-timestamp { | | |
| description | | |
| "Timestamp when the last default-origination was | | |
| done"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container last-update-group-start-timestamp { | | |
| description | | |
| "Last update-group timer start"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container last-update-group-expiry-timestamp { | | |
| description | | |
| "Last update-group timer expiry"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container first-update-queued-timestamp { | | |
| description | | |
| "Timestamp when the first update was queued"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container last-update-queued-timestamp { | | |
| description | | |
| "Timestamp when last update was queued"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container last-refresh-update-queued-timestamp { | | |
| description | | |
| "Timestamp when the last refresh update was | | |
| queued"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container first-update-write-timestamp { | | |
| description | | |
| "Timestamp when the first update was written"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container last-update-write-timestamp { | | |
| description | | |
| "Timestamp when the last update was written"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container last-refresh-update-write-timestamp { | | |
| description | | |
| "Timestamp when the last refresh update written"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container update-statistics { | | |
| description | | |
| "BGP update generation statistics update"; | | |
| uses BGP-UPDGEN-STATS-BAG; | | |
| } | | |
| leaf process-id { | | |
| type uint32; | | |
| description | | |
| "ProcessID"; | | |
| } | | |
| leaf update-vrf-name { | | |
| type string; | | |
| description | | |
| "VRF Name"; | | |
| } | | |
| leaf update-group-af-name { | | |
| type Bgp-afi; | | |
| description | | |
| "Address family identifier"; | | |
| } | | |
| leaf update-filter-group-index { | | |
| type uint32; | | |
| description | | |
| "Filter-group index"; | | |
| } | | |
| leaf refresh-filter-group-index { | | |
| type uint32; | | |
| description | | |
| "BGP update generation refresh Filter-group index"; | | |
| } | | |
| leaf sub-group-index-xr { | | |
| type uint32; | | |
| description | | |
| "BGP update generation index for sub-group"; | | |
| } | | |
| leaf refresh-sub-group-index { | | |
| type uint32; | | |
| description | | |
| "BGP update generation refresh Sub-group index"; | | |
| } | | |
| leaf refresh-sub-group-id { | | |
| type uint32; | | |
| description | | |
| "ID of the refresh subgroup for BGP update | | |
| generation"; | | |
| } | | |
| leaf update-group-index-xr { | | |
| type uint32; | | |
| description | | |
| "Index of this BGP Update-group"; | | |
| } | | |
| leaf update-main-table-version { | | |
| type uint64; | | |
| description | | |
| "Main table version"; | | |
| } | | |
| leaf update-vrf-table-rib-version { | | |
| type uint64; | | |
| description | | |
| "VRF Table RIB version"; | | |
| } | | |
| leaf update-out-queue-messages { | | |
| type uint32; | | |
| description | | |
| "OutQueue messages"; | | |
| } | | |
| leaf update-out-queue-size { | | |
| type uint32; | | |
| description | | |
| "OutQueue size"; | | |
| } | | |
| leaf refresh-update-out-queue-messages { | | |
| type uint32; | | |
| description | | |
| "Refresh OutQueue messages"; | | |
| } | | |
| leaf refresh-update-out-queue-size { | | |
| type uint32; | | |
| description | | |
| "Refresh OutQueue size"; | | |
| } | | |
| leaf update-filter-group-messages { | | |
| type uint32; | | |
| description | | |
| "The number of messages on the BGP filter-group"; | | |
| } | | |
| leaf version { | | |
| type uint64; | | |
| description | | |
| "Version up to which we have generated updates | | |
| for BGP"; | | |
| } | | |
| leaf pending-target-version { | | |
| type uint64; | | |
| description | | |
| "Version of pending target for BGP update | | |
| generation"; | | |
| } | | |
| leaf next-resume-version { | | |
| type uint64; | | |
| description | | |
| "Version number identifying the next to process | | |
| when tablewalk has been interrupted"; | | |
| } | | |
| leaf ack-version { | | |
| type uint64; | | |
| description | | |
| "Identifying the prefixs that have been | | |
| advertisedto the peer and acknowledged by it"; | | |
| } | | |
| leaf synced-ack-version { | | |
| type uint64; | | |
| description | | |
| "Peer acked version that was previously | | |
| synchronized"; | | |
| } | | |
| leaf outstanding-version-count { | | |
| type uint32; | | |
| description | | |
| "The number of all outstanding version objects | | |
| for thisneighbor address-family"; | | |
| } | | |
| leaf update-refresh-version { | | |
| type uint64; | | |
| description | | |
| "Refresh version"; | | |
| } | | |
| leaf refresh-requested-target-version { | | |
| type uint64; | | |
| description | | |
| "Requested refresh target version"; | | |
| } | | |
| leaf update-refresh-target-version { | | |
| type uint64; | | |
| description | | |
| "Target version for update generation in response | | |
| to arefresh request"; | | |
| } | | |
| leaf refresh-pending-target-version { | | |
| type uint64; | | |
| description | | |
| "Pending refresh target version"; | | |
| } | | |
| leaf refresh-next-resume-version { | | |
| type uint64; | | |
| description | | |
| "Version number identifying the next to process | | |
| whena table walk has been interrupted"; | | |
| } | | |
| leaf refresh-ack-version { | | |
| type uint64; | | |
| description | | |
| "Versio of the Refresh Ack for BGP update | | |
| generation"; | | |
| } | | |
| leaf last-default-originate-age { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time since last default-origination event (in | | |
| seconds)"; | | |
| } | | |
| leaf default-originate-state { | | |
| type int32; | | |
| description | | |
| "BGP update generation default originate state | | |
| information"; | | |
| } | | |
| leaf default-originate-internal-context { | | |
| type int32; | | |
| description | | |
| "BGP update generation default originate context | | |
| stateinformation"; | | |
| } | | |
| leaf is-eor-outstanding { | | |
| type boolean; | | |
| description | | |
| "Number of EORs outstanding"; | | |
| } | | |
| leaf outbound-refresh-count { | | |
| type uint32; | | |
| description | | |
| "Refresh Outbound count"; | | |
| } | | |
| leaf inbound-refresh-count { | | |
| type uint32; | | |
| description | | |
| "Refresh Inbound count"; | | |
| } | | |
| leaf is-update-group-timer-running { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if update-group timer is | | |
| running"; | | |
| } | | |
| leaf current-update-group-af-name { | | |
| type Bgp-afi; | | |
| description | | |
| "Current Update-group address-family identifier"; | | |
| } | | |
| leaf last-update-group-af-name { | | |
| type Bgp-afi; | | |
| description | | |
| "Last Update-group address-family identifier"; | | |
| } | | |
| leaf last-update-queued-age { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time since last update queued event (in seconds)"; | | |
| } | | |
| leaf last-refresh-update-queued-age { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time since last refresh update queued event (in | | |
| seconds)"; | | |
| } | | |
| leaf last-update-write-age { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time since last update write event (in seconds)"; | | |
| } | | |
| leaf last-refresh-update-write-age { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time since last refresh update write event (in | | |
| seconds)"; | | |
| } | | |
| leaf slow-peer-static-or-dynamic { | | |
| type Bgp-slow-peer-static-dynamic; | | |
| description | | |
| "Slow Peer in static or dynamic detected state"; | | |
| } | | |
| leaf slow-peer-detection-time-stamp { | | |
| type uint32; | | |
| description | | |
| "Slow Peer Detection Timestamp"; | | |
| } | | |
| leaf is-neighbor-slow-peer-static { | | |
| type boolean; | | |
| description | | |
| "Is Neighbor Slow Peer Static"; | | |
| } | | |
| leaf neighbor-refresh-state { | | |
| type Bgp-updgen-nbr-refresh-state; | | |
| description | | |
| "Neighbor Refresh State"; | | |
| } | | |
| leaf update-msg-pointer { | | |
| type uint64; | | |
| description | | |
| "Update Message pointer"; | | |
| } | | |
| list slow-peer-versions { | | |
| description | | |
| "List of slow peer versions"; | | |
| uses BGP-SLOW-PEER-VER-BAG; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-LINKED-EPE { | | |
| description | | description |
| "BGP LINKED EPE"; | | "Nexthop address"; |
| | | uses BGP-ADDRTYPE; |
| | | } |
| leaf epe-key-length { | | leaf epe-key-length-xr { |
| type uint8; | | type uint8; |
| description | | description |
| "EPE key length in bits"; | | "EPE key length in bits"; |
| } | | } |
| n | leaf epe-type { | n | leaf epe-version { |
| | | type uint32; |
| | | description |
| | | "EPE object's version"; |
| | | } |
| | | leaf epe-flags { |
| type uint8; | | type uint8; |
| description | | description |
| n | "Type of EPE object"; | n | "EPE object's flags"; |
| | | } |
| | | leaf epe-local-asn { |
| | | type uint32; |
| | | description |
| | | "Local AS Number"; |
| | | } |
| | | leaf epe-remote-asn { |
| | | type uint32; |
| | | description |
| | | "Remote AS Number"; |
| | | } |
| | | leaf epe-remote-router-id { |
| | | type uint32; |
| | | description |
| | | "Remote router id"; |
| | | } |
| | | leaf epe-local-router-id { |
| | | type uint32; |
| | | description |
| | | "Local router id"; |
| | | } |
| | | leaf label { |
| | | type uint32; |
| | | description |
| | | "Label assigned to the RPCnext-hop set"; |
| | | } |
| | | leaf ref-count { |
| | | type uint32; |
| | | description |
| | | "Refcount"; |
| | | } |
| | | leaf rpc-set-object-id { |
| | | type uint32; |
| | | description |
| | | "RPC set object ID"; |
| } | | } |
| list epe-key { | | list epe-key { |
| description | | description |
| "Key of EPE object"; | | "Key of EPE object"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "Key of EPE object"; | | "Key of EPE object"; |
| } | | } |
| } | | } |
| n | } | n | |
| | | |
| grouping BGP-EPE-SET-BAG { | | |
| description | | |
| "BGP EPE SET BAG"; | | |
| container epe-local-address { | | |
| description | | |
| "Local address"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| container epe-next-hop { | | |
| description | | |
| "Nexthop address"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| leaf epe-key-length { | | |
| type uint8; | | |
| description | | |
| "EPE key length in bits"; | | |
| } | | |
| leaf epe-type-xr { | | |
| type uint8; | | |
| description | | |
| "Type of EPE object"; | | |
| } | | |
| leaf epe-version { | | |
| type uint64; | | |
| description | | |
| "EPE object's version"; | | |
| } | | |
| leaf epe-flags { | | |
| type uint16; | | |
| description | | |
| "EPE object's flags"; | | |
| } | | |
| leaf epe-local-asn { | | |
| type uint32; | | |
| description | | |
| "Local AS Number"; | | |
| } | | |
| leaf epe-remote-asn { | | |
| type uint32; | | |
| description | | |
| "Remote AS Number"; | | |
| } | | |
| leaf epe-remote-router-id { | | |
| type uint32; | | |
| description | | |
| "BGP egress peer engineeringremote router id"; | | |
| } | | |
| leaf epe-local-router-id { | | |
| type uint32; | | |
| description | | |
| "BGP egress peer engineeringlocal router id"; | | |
| } | | |
| leaf label { | | |
| type uint32; | | |
| description | | |
| "Label assigned to the RPCnext-hop set"; | | |
| } | | |
| leaf ref-count { | | |
| type uint32; | | |
| description | | |
| "Reference count indicates numberof places being | | |
| updated"; | | |
| } | | |
| leaf rpc-set-object-id { | | |
| type uint32; | | |
| description | | |
| "RPC set object ID"; | | |
| } | | |
| list epe-key { | | |
| description | | |
| "Key of EPE object"; | | |
| leaf entry { | | |
| type uint8; | | |
| description | | |
| "Key of EPE object"; | | |
| } | | |
| } | | |
| list nexthop-id { | | list nexthop-id { |
| description | | description |
| "List of nexthop ID of EPE"; | | "List of nexthop ID of EPE"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "List of nexthop ID of EPE"; | | "List of nexthop ID of EPE"; |
| } | | } |
| } | | } |
| list ifhandle { | | list ifhandle { |
| description | | description |
| "List of ifhandle of EPE"; | | "List of ifhandle of EPE"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "List of ifhandle of EPE"; | | "List of ifhandle of EPE"; |
| } | | } |
| } | | } |
| list first-hop { | | list first-hop { |
| description | | description |
| "List of firsthops of EPE"; | | "List of firsthops of EPE"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| n | list linked-epe { | n | } |
| | | |
| | | grouping BGP-PATH-ELEM-BAG { |
| description | | description |
| "List of EPE objects linked to this current EPE | | "BGP path element"; |
| object"; | | container pelem-path-nexthop { |
| uses BGP-LINKED-EPE; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-NBR-THROTL-STATS-BAG { | | |
| description | | description |
| "BGP NBR THROTL STATS BAG"; | | "Path nexthop address"; |
| leaf throttle-start-time { | | uses BGP-ADDRTYPE; |
| | | } |
| | | container nh-tunnel { |
| | | description |
| | | "NH tunnel information"; |
| | | uses BGP-TE-TUNNEL; |
| | | } |
| | | container pelem-path-neighbor-addr { |
| | | description |
| | | "Path neighbor address"; |
| | | uses BGP-ADDRTYPE; |
| | | } |
| | | leaf pelem-path-id { |
| | | type uint32; |
| | | description |
| | | "Local Path ID"; |
| | | } |
| | | leaf pelem-version { |
| | | type uint32; |
| | | description |
| | | "Version"; |
| | | } |
| | | leaf pelem-flags { |
| | | type uint32; |
| | | description |
| | | "Flags"; |
| | | } |
| | | leaf pelem-gw-metric { |
| | | type uint32; |
| | | description |
| | | "Gateway metric"; |
| | | } |
| | | leaf pelem-path-flags { |
| type uint64; | | type uint64; |
| description | | description |
| n | "Time when the IO operation for the neighbor | n | "Path flags"; |
| entered the throttled state in nsec since epoch"; | | |
| } | | |
| leaf throttle-duration { | | |
| type uint32; | | |
| description | | |
| "Duration of the throttled state in msec"; | | |
| } | | |
| leaf throttle-msg-count { | | |
| type uint32; | | |
| description | | |
| "Number of messages handled during throttled | | |
| state"; | | |
| } | | |
| leaf throttle-queue-hwm { | | |
| type uint32; | | |
| description | | |
| "High watermark of the number of messages in | | |
| queue during throttled state"; | | |
| } | | |
| } | | } |
| | | leaf pelem-path-peer-path-id { |
| grouping BGP-NBR-GSHUT { | | type uint32; |
| description | | description |
| "BGP NBR GSHUT"; | | "Path peer path ID"; |
| leaf gshut-exists { | | |
| type boolean; | | |
| description | | |
| "Graceful Maintenance enabled"; | | |
| } | | } |
| n | leaf gshut-local-active { | n | leaf pelem-table-attr-version { |
| type boolean; | | |
| description | | |
| "Graceful Maintenance locally activated"; | | |
| } | | |
| leaf gshut-active { | | |
| type boolean; | | |
| description | | |
| "Graceful Maintenance activated"; | | |
| } | | |
| leaf gshut-locpref-set { | | |
| type boolean; | | |
| description | | |
| "Graceful Maintenance Local Preference set"; | | |
| } | | |
| leaf gshut-locpref { | | |
| type uint32; | | |
| description | | |
| "Graceful Maintenance Local Preference"; | | |
| } | | |
| leaf gshut-prepends { | | |
| type uint8; | | type uint32; |
| description | | |
| "Graceful Maintenance number of AS prepends"; | | |
| } | | |
| leaf gshut-interface-active { | | |
| type boolean; | | |
| description | | |
| "Graceful Maintenance activated at Interface"; | | |
| } | | |
| leaf gshut-location-active { | | |
| type boolean; | | |
| description | | |
| "Graceful Maintenance activated at Location"; | | |
| } | | |
| leaf gshut-all-nbr-active { | | |
| type boolean; | | |
| description | | |
| "Graceful Maintenance globally activated"; | | |
| } | | |
| leaf gshut-bandwidth-aware-set { | | |
| type boolean; | | |
| description | | |
| "Graceful Maintenance Bandwidth Aware Configured"; | | |
| } | | |
| leaf gshut-bandwidth-aware-state { | | |
| type Bgp-gshut-bw-edm-state; | | |
| description | | |
| "Graceful Maintenance Bandwidth Aware Operational | | |
| State"; | | |
| } | | |
| leaf gshut-bandwidth-aware-effective-link-bandwidth { | | |
| type uint64; | | |
| description | | |
| "Effective Link Bandwidth"; | | |
| } | | |
| leaf gshut-bandwidth-aware-total-link-bandwidth { | | |
| type uint64; | | |
| description | | |
| "Total Link Bandwidth"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-NBR-MSG-STATS-UNIT { | | |
| description | | description |
| "BGP NBR MSG STATS UNIT"; | | "Table Attr version"; |
| container last-time-spec { | | } |
| | | leaf pelem-path-table-attr-version { |
| | | type uint32; |
| | | description |
| | | "Path Table Attr version"; |
| | | } |
| | | leaf pelem-no-bestpath-table-attr-version { |
| | | type uint32; |
| | | description |
| | | "No-bestpath Table Attr version"; |
| | | } |
| | | leaf pelem-no-addpath-table-attr-version { |
| | | type uint32; |
| | | description |
| | | "No-addpath Table Attr version"; |
| | | } |
| | | leaf is-perm-path-pelem { |
| | | type boolean; |
| | | description |
| | | "Pelem for permanent path"; |
| | | } |
| | | } |
| | | |
| | | grouping BGP-NET-BAG { |
| description | | description |
| "BGP neighbor message statisticslast timespec"; | | "BGP network"; |
| | | container bgp-prefix { |
| | | description |
| | | "BGP prefix"; |
| | | uses BGP-PREFIXTYPE; |
| | | } |
| | | container version-timestamp { |
| | | description |
| | | "Version timestamp"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| n | leaf count { | n | container version-age { |
| type uint32; | | |
| description | | |
| "Count"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-NBR-MSG-STATS-OP { | | |
| description | | description |
| "BGP NBR MSG STATS OP"; | | "Version age"; |
| container tx { | | uses BGP-TIMESPEC; |
| description | | |
| "Transmit"; | | |
| uses BGP-NBR-MSG-STATS-UNIT; | | |
| } | | |
| container rx { | | |
| description | | |
| "Receive"; | | |
| uses BGP-NBR-MSG-STATS-UNIT; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-NBR-MSG-STATS { | | |
| description | | |
| "BGP NBR MSG STATS"; | | |
| container open { | | |
| description | | |
| "Open"; | | |
| uses BGP-NBR-MSG-STATS-OP; | | |
| } | | |
| container notification { | | |
| description | | |
| "BGP neighbor messagestatistics notification"; | | |
| uses BGP-NBR-MSG-STATS-OP; | | |
| } | | |
| container update { | | |
| description | | |
| "BGP neighbor message statisticsupdate"; | | |
| uses BGP-NBR-MSG-STATS-OP; | | |
| } | | |
| container keepalive { | | |
| description | | |
| "Message sent between BGP neighborsto check the | | |
| link between is operating"; | | |
| uses BGP-NBR-MSG-STATS-OP; | | |
| } | | |
| container route-refresh { | | |
| description | | |
| "BGP neighbor message statisticsroute refresh"; | | |
| uses BGP-NBR-MSG-STATS-OP; | | |
| } | | |
| container total { | | |
| description | | |
| "Total"; | | |
| uses BGP-NBR-MSG-STATS-OP; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-PERF-NBR-AF { | | |
| description | | |
| "BGP PERF NBR AF"; | | |
| leaf sub-group-pending-message-count { | | |
| type uint32; | | |
| description | | |
| "No. of sub-group messages waiting to be sent out | | |
| on this neighbor -- DEPRECATED -- "; | | |
| } | | |
| leaf processed-messages { | | |
| type uint32; | | |
| description | | |
| "Number of messages processed from the neighbor's | | |
| write queue"; | | |
| } | | |
| leaf sent-messages { | | |
| type uint32; | | |
| description | | |
| "Number of messages sent from the neighbor's | | |
| write queue"; | | |
| } | | |
| leaf split-horizon-update-transmit { | | |
| type uint32; | | |
| description | | |
| "No. of update messages with split-horizon flag | | |
| that were sent out"; | | |
| } | | |
| leaf split-horizon-update-blocked { | | |
| type uint32; | | |
| description | | |
| "No. of update messages with split-horizon flag | | |
| that were blocked"; | | |
| } | | |
| leaf split-horizon-withdraw-transmit { | | |
| type uint32; | | |
| description | | |
| "No. of withdraw messages with split-horizon flag | | |
| that were sent out"; | | |
| } | | |
| leaf split-horizon-withdraw-blocked { | | |
| type uint32; | | |
| description | | |
| "No. of withdraw messages with split-horizon flag | | |
| that were blocked"; | | |
| } | | |
| leaf refresh-mismatch-update-blocked { | | |
| type uint32; | | |
| description | | |
| "No. of update messages blocked due toRefresh | | |
| subgroup mismatch"; | | |
| } | | |
| leaf refresh-mismatch-withdraw-spurious { | | |
| type uint32; | | |
| description | | |
| "No. of withdraw messages spuriously blocked due | | |
| toRefresh subgroup mismatch"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-NBR-AF { | | |
| description | | |
| "BGP neighbor address family specific information"; | | |
| container neighbor-af-performance-statistics { | | |
| description | | |
| "Neighbor AF statistics"; | | |
| uses BGP-PERF-NBR-AF; | | |
| } | | } |
| leaf af-name { | | leaf af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Address family identifier"; | | "Address family identifier"; |
| } | | } |
| n | leaf is-neighbor-route-reflector-client { | n | leaf process-instance-id { |
| type boolean; | | |
| description | | |
| "Nbr is a route reflector client"; | | |
| } | | |
| leaf is-legacy-pe-rt { | | |
| type boolean; | | |
| description | | |
| "Nbr accepts route from legacy PE for | | |
| RT-Constraint AF "; | | |
| } | | |
| leaf is-neighbor-af-capable { | | |
| type boolean; | | |
| description | | |
| "Address family capability received from neighbor"; | | |
| } | | |
| leaf is-soft-reconfiguration-inbound-allowed { | | |
| type boolean; | | |
| description | | |
| "Inbound soft reconfiguration allowed"; | | |
| } | | |
| leaf is-use-soft-reconfiguration-always-on { | | |
| type boolean; | | |
| description | | |
| "Soft reconf overrides route refresh"; | | |
| } | | |
| leaf remove-private-as-from-updates { | | |
| type boolean; | | |
| description | | |
| "Private AS numbers removed from updates to this | | |
| nbr"; | | |
| } | | |
| leaf remove-private-as-entire-aspath-from-updates { | | |
| type boolean; | | |
| description | | |
| "Private AS numbers removed from updates to | | |
| thisnbr only if the aspath hasonly private ASes"; | | |
| } | | |
| leaf remove-private-as-from-inbound-updates { | | |
| type boolean; | | |
| description | | |
| "Private AS numbers removed from updates from | | |
| this nbr"; | | |
| } | | |
| leaf remove-private-as-entire-aspath-from-inbound-updates { | | |
| type boolean; | | |
| description | | |
| "Private AS numbers removed from updates from | | |
| this nbr only if the aspath has only private | | |
| ASes"; | | |
| } | | |
| leaf flowspec-validation-d-isable { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if bgp neighbor address-family | | |
| flowspec validation is disabled"; | | |
| } | | |
| leaf flowspec-redirect-validation-d-isable { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if flowspec redirect nexthop | | |
| validation is disabled"; | | |
| } | | |
| leaf orr-group-name { | | |
| type string; | | |
| description | | |
| "ORR Group Name"; | | |
| } | | |
| leaf orr-group-index { | | |
| type uint32; | | |
| description | | |
| "ORR Group Index"; | | |
| } | | |
| leaf is-orr-root-address-configured { | | |
| type boolean; | | |
| description | | |
| "ORR Root address configuredfor the neighbor | | |
| connection"; | | |
| } | | |
| leaf advertise-afi { | | |
| type boolean; | | |
| description | | |
| "Encode in Advertise AFI"; | | |
| } | | |
| leaf advertise-afi-reorg { | | |
| type boolean; | | |
| description | | |
| "Encode in Advertise AFI"; | | |
| } | | |
| leaf advertise-afi-disable { | | |
| type boolean; | | |
| description | | |
| "Encode in Advertise AFI"; | | |
| } | | |
| leaf encapsulation-type { | | |
| type uint32; | | |
| description | | |
| "BGP neighbor address-familyencapsulation type"; | | |
| } | | |
| leaf advertise-rt-type { | | |
| type uint8; | | type uint8; |
| description | | description |
| n | "BGP neighbor address-familyadvertise route | n | "Process instance ID"; |
| target type"; | | |
| } | | } |
| n | leaf advertise-afi-def-vrf-imp-disable { | n | leaf has-inconsistent-paths { |
| type boolean; | | type boolean; |
| n | description | n | |
| "Advertise of default VRF import disable"; | | |
| } | | |
| leaf advertise-evpnv4-afi-def-vrf-imp-disable { | | |
| type boolean; | | |
| description | | |
| "Advertise of v4 default VRF import disable"; | | |
| } | | |
| leaf advertise-evpnv6-afi-def-vrf-imp-disable { | | |
| type boolean; | | |
| description | | |
| "Advertise of v6 default VRF import disable"; | | |
| } | | |
| leaf advertise-afi-vrf-re-imp-disable { | | |
| type boolean; | | |
| description | | |
| "Advertise of VRF re-import disable"; | | |
| } | | |
| leaf advertise-evpnv4-afi-vrf-re-imp-disable { | | |
| type boolean; | | |
| description | | |
| "Advertise of v4 VRF re-import disable"; | | |
| } | | |
| leaf advertise-evpnv6-afi-vrf-re-imp-disable { | | |
| type boolean; | | |
| description | | |
| "Advertise of v6 VRF re-import disable"; | | |
| } | | |
| leaf advertise-afi-eo-r-ready { | | |
| type boolean; | | |
| description | | |
| "EoR Can be sent for Advertise AFI"; | | |
| } | | |
| leaf always-use-next-hop-local { | | |
| type boolean; | | |
| description | | |
| "Local router always used for next-hop"; | | |
| } | | |
| leaf sent-community-to-neighbor { | | |
| type boolean; | | |
| description | | |
| "Community attribute sent to neighbor"; | | |
| } | | |
| leaf sent-gshut-community-to-neighbor { | | |
| type boolean; | | |
| description | | |
| "GSHUT Community attribute sent to neighbor"; | | |
| } | | |
| leaf sent-extended-community-to-neighbor { | | |
| type boolean; | | |
| description | | |
| "Extended community attribute sent to neighbor"; | | |
| } | | |
| leaf default-originate-vpn-index { | | |
| type uint32; | | |
| description | | |
| "Default orig vpn indexto find bitfield for a nbr | | |
| af"; | | |
| } | | |
| leaf neighbor-default-originate { | | |
| type boolean; | | |
| description | | |
| "Neighbor originates default"; | | |
| } | | |
| leaf is-orf-sent { | | |
| type boolean; | | |
| description | | |
| "Outbound route filter sent to neighbor"; | | |
| } | | |
| leaf is-update-deferred { | | |
| type boolean; | | |
| description | | |
| "Update deferred until ORF/route refresh received"; | | |
| } | | |
| leaf is-orf-send-scheduled { | | |
| type boolean; | | |
| description | | |
| "Scheduled to send prefix based ORF"; | | |
| } | | |
| leaf update-group-number { | | |
| type uint32; | | |
| description | | |
| "Update group index"; | | |
| } | | |
| leaf filter-group-index { | | |
| type uint32; | | |
| description | | |
| "BGP neighbor address-familyfilter group index"; | | |
| } | | |
| leaf is-update-throttled { | | |
| type boolean; | | |
| description | | |
| "Updates Throttled becausewrite limit is reached"; | | |
| } | | |
| leaf is-update-leaving { | | |
| type boolean; | | |
| description | | |
| "Nbr leaving update-groupto another"; | | |
| } | | |
| leaf vpn-update-gen-enabled { | | |
| type boolean; | | |
| description | | |
| "RT Nbr enabled for updategento another"; | | |
| } | | |
| leaf vpn-update-gen-trigger-enabled { | | |
| type boolean; | | |
| description | | |
| "RT Nbr enabled for updategento another"; | | |
| } | | |
| leaf is-addpath-send-operational { | | |
| type boolean; | | |
| description | | |
| "Addpath is operational on send-side"; | | |
| } | | |
| leaf is-addpath-receive-operational { | | |
| type boolean; | | |
| description | | |
| "Addpath is operational on receive-side"; | | |
| } | | |
| leaf neighbor-version { | | |
| type uint64; | | |
| description | | |
| "BGP neighbor version for theaddress-family"; | | |
| } | | |
| leaf weight { | | |
| type uint32; | | |
| description | | |
| "Weight for this AF"; | | |
| } | | |
| leaf max-prefix-limit { | | |
| type uint32; | | |
| description | | |
| "Max limit for # of prefixes"; | | |
| } | | |
| leaf use-max-prefix-warning-only { | | |
| type boolean; | | |
| description | | |
| "Warning only when maximum prefix limit reached"; | | |
| } | | |
| leaf max-prefix-discard-extra-paths { | | |
| type boolean; | | |
| description | | |
| "Discard extra paths when prefix limit reached"; | | |
| } | | |
| leaf max-prefix-exceed-discard-paths { | | |
| type boolean; | | |
| description | | |
| "Did we discard extra paths when prefix limit | | |
| reached"; | | |
| } | | |
| leaf max-prefix-threshold-percent { | | |
| type uint8; | | |
| units "percentage"; | | |
| description | | |
| "Percentage of maximum no. of prefixes at which | | |
| to generate warning"; | | |
| } | | |
| leaf max-prefix-discard-paths-count { | | |
| type uint32; | | |
| description | | |
| "Number of discarded paths after prefix limit | | |
| reached"; | | |
| } | | |
| leaf max-prefix-restart-time { | | |
| type uint16; | | |
| units "minute"; | | |
| description | | |
| "Time interval (in minutes) after which peering | | |
| session will be reestablished"; | | |
| } | | |
| leaf prefixes-accepted { | | |
| type uint32; | | |
| description | | |
| "Number of prefixes acceptedfrom this BGP | | |
| neighbor"; | | |
| } | | |
| leaf prefixes-accepted-hwm { | | |
| type uint32; | | |
| description | | |
| "Number of prefixes acceptedfrom this BGP | | |
| neighbor High Water Mark"; | | |
| } | | |
| leaf prefixes-accepted-hwm-timestamp { | | |
| type uint64; | | |
| description | | |
| "Time When prefixes accepted entered high water | | |
| mark"; | | |
| } | | |
| leaf prefixes-accepted-modified { | | |
| type uint32; | | |
| description | | |
| "Number of prefixes accepted modifed by | | |
| soft-reconfigfrom this BGP neighbor"; | | |
| } | | |
| leaf prefixes-accepted-modified-hwm { | | |
| type uint32; | | |
| description | | |
| "Number of prefixes accepted modifed by | | |
| soft-reconfigfrom this BGP neighbor High Water | | |
| Mark"; | | |
| } | | |
| leaf prefixes-accepted-modified-hwm-timestamp { | | |
| type uint64; | | |
| description | | |
| "Time When prefixes accepted modified entered | | |
| high water mark"; | | |
| } | | |
| leaf prefixes-synced { | | |
| type uint32; | | |
| description | | |
| "Number of prefixes synced to standby"; | | |
| } | | |
| leaf prefixes-withdrawn-not-found { | | |
| type uint32; | | |
| description | | |
| "Number of prefixes withdrawn butnot found gor | | |
| this BGP neighbor"; | | |
| } | | |
| leaf prefixes-denied { | | |
| type uint32; | | |
| description | | |
| "Number of prefixes denied forthis BGP neighbor"; | | |
| } | | |
| leaf prefixes-denied-no-policy { | | |
| type uint32; | | |
| description | | |
| "No. of prefixes denied because there was no | | |
| inbound policy"; | | |
| } | | |
| leaf prefixes-denied-rt-permit { | | |
| type uint32; | | |
| description | | |
| "No. of prefixes denied because RT extended | | |
| community is not imported"; | | |
| } | | |
| leaf prefixes-denied-orf-policy { | | |
| type uint32; | | |
| description | | |
| "No. of prefixes denied by prefix based ORF | | |
| policy"; | | |
| } | | |
| leaf prefixes-denied-policy { | | |
| type uint32; | | |
| description | | |
| "No. of prefixes denied by inbound policy"; | | |
| } | | |
| leaf prefixes-received { | | |
| type uint32; | | |
| description | | |
| "No. of prefixes received prior to inbound policy | | |
| run"; | | |
| } | | |
| leaf number-of-bestpaths { | | |
| type uint32; | | |
| description | | |
| "No. of bestpaths from this neighbor"; | | |
| } | | |
| leaf number-of-best-externalpaths { | | |
| type uint32; | | |
| description | | |
| "No. of best-external paths from this neighbor"; | | |
| } | | |
| leaf prefixes-advertised { | | |
| type uint32; | | |
| description | | |
| "Number of prefixes advertisedfor this BGP | | |
| neighbor"; | | |
| } | | |
| leaf prefixes-be-advertised { | | |
| type uint32; | | |
| description | | |
| "Number of BE prefixes advertised"; | | |
| } | | |
| leaf prefixes-suppressed { | | |
| type uint32; | | |
| description | | |
| "Number of prefixes suppressed"; | | |
| } | | |
| leaf prefixes-withdrawn { | | |
| type uint32; | | |
| description | | |
| "Number of prefixes withdrawn"; | | |
| } | | |
| leaf is-peer-orf-capable { | | |
| type boolean; | | |
| description | | |
| "Peer has outbound route filter capability"; | | |
| } | | |
| leaf is-advertised-orf-send { | | |
| type boolean; | | |
| description | | |
| "Prefix based ORF send mode capability advertised"; | | |
| } | | |
| leaf is-received-orf-send-capable { | | |
| type boolean; | | |
| description | | |
| "Prefix based ORF send mode capability received"; | | |
| } | | |
| leaf is-advertised-orf-receive { | | |
| type boolean; | | |
| description | | |
| "Prefix based ORF receive mode capability | | |
| advertised"; | | |
| } | | |
| leaf is-received-orf-receive-capable { | | |
| type boolean; | | |
| description | | |
| "Prefix based ORF receive mode capability | | |
| received"; | | |
| } | | |
| leaf is-advertised-graceful-restart { | | |
| type boolean; | | |
| description | | |
| "Graceful Restart Capability advertised"; | | |
| } | | |
| leaf is-graceful-restart-state-flag { | | |
| type boolean; | | |
| description | | |
| "Restart state flag enabled"; | | |
| } | | |
| leaf is-received-graceful-restart-capable { | | |
| type boolean; | | |
| description | | |
| "Graceful Restart Capability received"; | | |
| } | | |
| leaf is-add-path-send-capability-advertised { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if addpath send capability sent | | |
| to BGPneighbor"; | | |
| } | | |
| leaf is-add-path-send-capability-received { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if addpath send capability | | |
| received from BGP neighbor"; | | |
| } | | |
| leaf is-add-path-receive-capability-advertised { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if addpath receive capability | | |
| advertised from BGP neighbor"; | | |
| } | | |
| leaf is-add-path-receive-capability-received { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate addpath receive capability | | |
| received from BGPneighbor"; | | |
| } | | |
| leaf is-ext-nh-encoding-capability-received { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate extended nexthop encoding | | |
| capability received from BGP neighbor"; | | |
| } | | |
| leaf is-ext-nh-encoding-capability-sent { | | |
| type boolean; | | |
| description | | |
| "Extended nexhop encoding capability Sent"; | | |
| } | | |
| leaf restart-time { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Restart time advertised (seconds)"; | | |
| } | | |
| leaf local-restart-time { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Local Restart time (seconds)"; | | |
| } | | |
| leaf stale-path-timeout { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Stale path timeout time (in seconds)"; | | |
| } | | |
| leaf rib-purge-timeout-value { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "RIB purge timeout time (in seconds)"; | | |
| } | | |
| leaf neighbor-preserved-forwarding-state { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate neighbor preserved in | | |
| forwarding state"; | | |
| } | | |
| leaf long-lived-graceful-restart-stale-time-configured { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if BGP neighbor long-lived | | |
| graceful-restart stale time is configured"; | | |
| } | | |
| leaf long-lived-graceful-restart-stale-time-sent { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Stale time sent in long-lived graceful-restart | | |
| capability (seconds)"; | | |
| } | | |
| leaf long-lived-graceful-restart-stale-time-accept { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Maximum long-lived graceful-restart stale time | | |
| acceptable from the neighbor (seconds)"; | | |
| } | | |
| leaf long-lived-graceful-restart-capability-received { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate long-lived graceful-restart | | |
| capability received from the neighbor"; | | |
| } | | |
| leaf long-lived-graceful-restart-stale-time-received { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Long-lived graceful-restart stale time received | | |
| from the neighbor (seconds)"; | | |
| } | | |
| leaf neighbor-preserved-long-lived-forwarding-state { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate BGP neighbor preserved | | |
| long-lived forwarding state"; | | |
| } | | |
| leaf neighbor-long-lived-graceful-restart-capable { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if BGP neighbor as long-lived | | |
| graceful-restartis capable"; | | |
| } | | |
| leaf neighbor-long-lived-graceful-restart-time-remaining { | | |
| type uint32; | | |
| description | | |
| "Remaining long-lived graceful-restart time"; | | |
| } | | |
| leaf route-refreshes-received { | | |
| type uint32; | | |
| description | | |
| "Number of route refresh requests received"; | | |
| } | | |
| leaf route-refreshes-sent { | | |
| type uint32; | | |
| description | | |
| "Number of route refresh requests sent"; | | |
| } | | |
| leaf refresh-target-version { | | |
| type uint64; | | |
| description | | |
| "Target version for refresh update generation"; | | |
| } | | |
| leaf refresh-version { | | |
| type uint64; | | |
| description | | |
| "Version till which refresh updates have been | | |
| generated"; | | |
| } | | |
| leaf refresh-acked-version { | | |
| type uint64; | | |
| description | | |
| "Version acked by the peer for refresh updates | | |
| sent"; | | |
| } | | |
| leaf is-prefix-orf-present { | | |
| type boolean; | | |
| description | | |
| "Outbound route filter prefix ORF present"; | | |
| } | | |
| leaf orf-entries-received { | | |
| type uint32; | | |
| description | | |
| "Number of outbound route filter entries received"; | | |
| } | | |
| leaf is-default-originate-sent { | | |
| type boolean; | | |
| description | | |
| "Default origination update sent"; | | |
| } | | |
| leaf route-policy-prefix-orf { | | |
| type string; | | |
| description | | |
| "Prefix based ORF for incoming updates"; | | |
| } | | |
| leaf route-policy-in { | | |
| type string; | | |
| description | | |
| "Incoming route policy name"; | | |
| } | | |
| leaf route-policy-out { | | |
| type string; | | |
| description | | |
| "Outgoing route policy name"; | | |
| } | | |
| leaf route-policy-ret { | | |
| type string; | | |
| description | | |
| "Retention route policy name"; | | |
| } | | |
| leaf route-policy-default-originate { | | |
| type string; | | |
| description | | |
| "Default-originate route policy name"; | | |
| } | | |
| leaf is-neighbor-ebgp-without-inbound-policy { | | |
| type boolean; | | |
| description | | |
| "eBGP neighbor with no configured inbound policy"; | | |
| } | | |
| leaf is-neighbor-ebgp-without-outbound-policy { | | |
| type boolean; | | |
| description | | |
| "eBGP neighbor with no configured outbound policy"; | | |
| } | | |
| leaf is-upd-orig-loopchk-disable-set { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if update out originator | | |
| loopcheck is disabled"; | | |
| } | | |
| leaf is-as-override-set { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate as override set for BGP | | |
| neighbor"; | | |
| } | | |
| leaf is-allow-as-in-set { | | |
| type boolean; | | |
| description | | |
| "Allowas-in set "; | | |
| } | | |
| leaf allow-as-in-count { | | |
| type uint32; | | |
| description | | |
| "Allowas-in count config"; | | |
| } | | |
| leaf is-allow-confed-as-in-set { | | |
| type boolean; | | |
| description | | |
| "Allowconfedas-in set "; | | |
| } | | |
| leaf allow-confed-as-in-count { | | |
| type uint32; | | |
| description | | |
| "Allowconfedas-in count config"; | | |
| } | | |
| leaf address-family-long-lived-time { | | |
| type uint32; | | |
| description | | |
| "AF specific Long-lived-time config"; | | |
| } | | |
| leaf eo-r-received-in-read-only { | | |
| type boolean; | | |
| description | | |
| "An EoR was received while in read-only mode"; | | |
| } | | |
| leaf acked-version { | | |
| type uint64; | | |
| description | | |
| "Version mapped from acked seqNo"; | | |
| } | | |
| leaf synced-acked-version { | | |
| type uint64; | | |
| description | | |
| "Version mapped from acked seqNo that was synced | | |
| last"; | | |
| } | | |
| leaf outstanding-version { | | |
| type uint32; | | |
| description | | |
| "No. of all outstanding version objects waiting | | |
| for ack from the peer"; | | |
| } | | |
| leaf outstanding-refresh-version { | | |
| type uint32; | | |
| description | | |
| "No. of only refresh version objects waiting for | | |
| ack from the peer"; | | |
| } | | |
| leaf outstanding-version-max { | | |
| type uint32; | | |
| description | | |
| "Version mapped from acked seqNo that was synced | | |
| last"; | | |
| } | | |
| leaf is-aigp-set { | | |
| type boolean; | | |
| description | | |
| "AIGP set "; | | |
| } | | |
| leaf is-rt-present { | | |
| type boolean; | | |
| description | | |
| "RT attribute list present"; | | |
| } | | |
| leaf is-rt-present-standby { | | |
| type boolean; | | |
| description | | |
| "RT attribute list present"; | | |
| } | | |
| leaf accept-own-enabled { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if Accept-Own is enabled"; | | |
| } | | |
| leaf selective-multipath-eligible { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if selective multipath is | | |
| eligible"; | | |
| } | | |
| leaf afrpki-disable { | | |
| type boolean; | | |
| description | | |
| "Prefix validation disabled"; | | |
| } | | |
| leaf afrpki-use-validity { | | |
| type boolean; | | |
| description | | |
| "Prefix v. use validity"; | | |
| } | | |
| leaf afrpki-allow-invalid { | | |
| type boolean; | | |
| description | | |
| "Prefix v. allow invalid"; | | |
| } | | |
| leaf afrpki-signal-ibgp { | | |
| type boolean; | | |
| description | | |
| "Prefix v. signal ibgp"; | | |
| } | | |
| leaf is-advertise-permanent-network { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if advertise is permanent | | |
| network"; | | |
| } | | |
| leaf is-send-mcast-attr { | | |
| type boolean; | | |
| description | | |
| "Send Mcast Attr"; | | |
| } | | |
| leaf import-stitching { | | |
| type boolean; | | |
| description | | |
| "Import Stitching enabled"; | | |
| } | | |
| leaf import-reoriginate { | | |
| type boolean; | | |
| description | | |
| "Import Reoriginate enabled"; | | |
| } | | |
| leaf import-reoriginate-stitching { | | |
| type boolean; | | |
| description | | |
| "Import Reoriginate Stitching enabled"; | | |
| } | | |
| leaf advertise-v4-flags { | | |
| type uint32; | | |
| description | | |
| "Advertise options for VPNV4"; | | |
| } | | |
| leaf advertise-v6-flags { | | |
| type uint32; | | |
| description | | |
| "Advertise options for VPNV6"; | | |
| } | | |
| leaf advertise-local-labeled-route-unicast { | | |
| type boolean; | | |
| description | | |
| "Advertise routes with "; | | |
| } | | |
| leaf prefixes-denied-non-cumulative { | | |
| type uint32; | | |
| description | | |
| "Number of prefixes exactly denied (non | | |
| cumulative)"; | | |
| } | | |
| leaf prefixes-denied-non-cumulative-hwm { | | |
| type uint32; | | |
| description | | |
| "Number of prefixes exactly denied (non | | |
| cumulative) High Water Mark"; | | |
| } | | |
| leaf prefixes-denied-non-cumulative-hwm-timestamp { | | |
| type uint64; | | |
| description | | |
| "Time When prefixes denied non cumulative entered | | |
| high water mark"; | | |
| } | | |
| leaf enable-label-stack { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if label stack is enabled"; | | |
| } | | |
| leaf ot-prov-track-enable { | | |
| type boolean; | | |
| description | | |
| "OT Provider Tracking enabled"; | | |
| } | | |
| leaf ot-prov-track-state { | | |
| type Bgp-track-state; | | |
| description | | |
| "OT Provider Tracking state"; | | |
| } | | |
| leaf ot-prov-track-in-gr-state { | | |
| type boolean; | | |
| description | | |
| "OT Provider Track in GR State"; | | |
| } | | |
| leaf ot-prov-track-eor-tmr-running { | | |
| type boolean; | | |
| description | | |
| "OT Provider Track EOR timer running"; | | |
| } | | |
| leaf slow-peer-state { | | |
| type Bgp-slow-peer-state; | | |
| description | | |
| "Slow Peer state"; | | |
| } | | |
| leaf slow-peer-detected { | | |
| type boolean; | | |
| description | | |
| "Detected Slow Peer"; | | |
| } | | |
| leaf slow-peer-processing { | | |
| type boolean; | | |
| description | | |
| "Processing Slow Peer"; | | |
| } | | |
| leaf slow-peer-threshold { | | |
| type uint16; | | |
| description | | |
| "Threshold for recovering a dynamic slow peer"; | | |
| } | | |
| leaf slow-peer-detection-count { | | |
| type uint32; | | |
| description | | |
| "Slow peer detection count"; | | |
| } | | |
| leaf slow-peer-recover-count { | | |
| type uint32; | | |
| description | | |
| "Slow peer recovery count"; | | |
| } | | |
| leaf slow-peer-trigger-count { | | |
| type uint32; | | |
| description | | |
| "Slow peer trigger count"; | | |
| } | | |
| leaf slow-peer-process-count { | | |
| type uint32; | | |
| description | | |
| "Slow peer process count"; | | |
| } | | |
| leaf delayed-path-count-total { | | |
| type uint32; | | |
| description | | |
| "Total number of paths delayed"; | | |
| } | | |
| leaf delayed-path-count-current { | | |
| type uint32; | | |
| description | | |
| "Current number of paths delayed"; | | |
| } | | |
| leaf addpath-receive-enable { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if addpath receive | | |
| functionality is enabled"; | | |
| } | | |
| leaf addpath-receive-disable { | | |
| type boolean; | | |
| description | | |
| "Flag indicates if addpath receive functionality | | |
| is disabled"; | | |
| } | | |
| leaf addpath-send-enable { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if addpath send functionality | | |
| is enabled"; | | |
| } | | |
| leaf addpath-send-disable { | | |
| type boolean; | | |
| description | | |
| "Flag indicates if addpath send functionality is | | |
| disabled"; | | |
| } | | |
| list extended-community { | | |
| description | | |
| "Extended community attribute"; | | |
| leaf entry { | | |
| type uint8; | | |
| description | | description |
| "Extended community attribute"; | | "Net has inconsistent paths"; |
| } | | } |
| } | | leaf is-net-aggregation-suppressed { |
| list extended-community-standby { | | type boolean; |
| description | | |
| "Extended community attribute"; | | |
| leaf entry { | | |
| type uint8; | | |
| description | | description |
| "Extended community attribute"; | | "Net suppressed due to aggregation"; |
| } | | } |
| } | | leaf is-net-ldp-signaled { |
| list version-bump-count { | | type boolean; |
| description | | |
| "Total version bumps per event"; | | |
| uses NBR-TOTAL-BUMPS; | | |
| } | | |
| list version-rate-stat { | | |
| max-elements "4"; | | |
| description | | |
| "Version bump stats per event per interval"; | | |
| uses NBR-VER-RATE; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-PERF-NBR { | | |
| description | | description |
| "BGP PERF NBR"; | | "L2VPN Net LDP signaled aggregation"; |
| container gshut-bandwidth-aware-last-enter-time-spec { | | |
| description | | |
| "Last Bandwidth Aware Graceful-Maintenance enter | | |
| timestamp"; | | |
| uses BGP-TIMESPEC; | | |
| } | | } |
| n | container gshut-bandwidth-aware-last-exit-time-spec { | n | leaf table-version { |
| description | | |
| "Last Bandwidth Aware Graceful-Maintenance exit | | |
| timestamp"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| leaf read-throttles { | | |
| type uint32; | | |
| description | | |
| "Number of partial read throttles"; | | |
| } | | |
| leaf low-throttled-read { | | |
| type uint32; | | |
| description | | |
| "Num socket reads after nbrs crossed low | | |
| threshold"; | | |
| } | | |
| leaf high-throttled-read { | | |
| type uint32; | | |
| description | | |
| "Num of socket reads after nbr crossed high | | |
| threshold"; | | |
| } | | |
| leaf time-since-last-throttled-read { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time (in secs) since last read after being | | |
| throttled"; | | |
| } | | |
| leaf read-calls-count { | | |
| type uint32; | | |
| description | | |
| "No. of calls to function to read inbound data"; | | |
| } | | |
| leaf read-messages-count { | | |
| type uint32; | | |
| description | | |
| "Number of BGP messages read"; | | |
| } | | |
| leaf data-bytes-read { | | |
| type uint32; | | |
| units "byte"; | | |
| description | | |
| "No. of bytes of data read"; | | |
| } | | |
| leaf io-read-time { | | |
| type uint32; | | |
| units "millisecond"; | | |
| description | | |
| "Time spent reading inbound data (milliseconds)"; | | |
| } | | |
| leaf write-calls-count { | | |
| type uint32; | | |
| description | | |
| "No. of calls to function to write outbound data"; | | |
| } | | |
| leaf data-bytes-written { | | |
| type uint32; | | |
| units "byte"; | | |
| description | | |
| "Number of bytes that havesent to peers"; | | |
| } | | |
| leaf io-write-time { | | |
| type uint32; | | |
| units "millisecond"; | | |
| description | | |
| "Time spent writing outbound data (milliseconds)"; | | |
| } | | |
| leaf last-sent-seq-no { | | |
| type uint32; | | |
| description | | |
| "Seq No of the last sent byte"; | | |
| } | | |
| leaf write-subgroup-calls-count { | | |
| type uint32; | | |
| description | | |
| "No. of calls to function to process sub-group | | |
| message list"; | | |
| } | | |
| leaf write-subgroup-messages-count { | | |
| type uint32; | | |
| description | | |
| "Number of sub-group msgs processed"; | | |
| } | | |
| leaf subgroup-list-time { | | |
| type uint32; | | |
| units "millisecond"; | | |
| description | | |
| "Time spent processing sub-group message list | | |
| (milliseconds)"; | | |
| } | | |
| leaf write-queue-calls-count { | | |
| type uint32; | | |
| description | | |
| "No. of calls to function to process write queue"; | | |
| } | | |
| leaf write-queue-messages-count { | | |
| type uint32; | | |
| description | | |
| "Number of write queue messages processed"; | | |
| } | | |
| leaf write-queue-time { | | |
| type uint32; | | |
| units "millisecond"; | | |
| description | | |
| "Time spent processing write queue (milliseconds)"; | | |
| } | | |
| leaf inbound-update-messages { | | |
| type uint32; | | |
| description | | |
| "Number of inbound update messages processed"; | | |
| } | | |
| leaf inbound-update-messages-time { | | |
| type uint32; | | |
| units "millisecond"; | | |
| description | | |
| "Time spent processing inbound update messages | | |
| (milliseconds)"; | | |
| } | | |
| leaf maximum-read-size { | | |
| type uint32; | | |
| units "millisecond"; | | |
| description | | |
| "Size of largest socket (milliseconds)"; | | |
| } | | |
| leaf actives { | | |
| type uint32; | | |
| description | | |
| "Number of retried Active opens for this neighbor"; | | |
| } | | |
| leaf failed-post-actives { | | |
| type uint32; | | |
| description | | |
| "Number of Active Opens that failed in the Post | | |
| Active State for this neighbor"; | | |
| } | | |
| leaf passives { | | |
| type uint32; | | |
| description | | |
| "Number of retried Passive opens for this | | |
| neighbor"; | | |
| } | | |
| leaf rejected-passives { | | |
| type uint32; | | |
| description | | |
| "Number of rejected Passive opens for this | | |
| neighbor"; | | |
| } | | |
| leaf active-collision { | | |
| type uint32; | | |
| description | | |
| "Number of Closed Active connections for this | | |
| neighbor due to collision "; | | |
| } | | |
| leaf passive-collision { | | |
| type uint32; | | |
| description | | |
| "Number of Closed Remote opens for this | | |
| neighborneighbor due to collision "; | | |
| } | | |
| leaf control-to-read-thread-trigger { | | |
| type uint32; | | |
| description | | |
| "Number of times io-control thread trigger read | | |
| thread"; | | |
| } | | |
| leaf control-to-write-thread-trigger { | | |
| type uint32; | | |
| description | | |
| "Number of times io-control thread trigger write | | |
| thread"; | | |
| } | | |
| leaf network-status { | | |
| type uint32; | | |
| description | | |
| "Socket status, TRUE if socket closed"; | | |
| } | | |
| leaf reset-flags { | | |
| type uint32; | | |
| description | | |
| "Reset flags, per thread"; | | |
| } | | |
| leaf nbr-flags { | | |
| type uint32; | | |
| description | | |
| "Nbr flags, per thread"; | | |
| } | | |
| leaf nbr-fd { | | |
| type int32; | | type uint32; |
| description | | |
| "Primary FD, per nbr"; | | |
| } | | |
| leaf reset-retries { | | |
| type uint8; | | |
| description | | |
| "Reset Retries, per nbr"; | | |
| } | | |
| leaf sync-flags { | | |
| type uint32; | | |
| description | | |
| "Sync flags, per nbr"; | | |
| } | | |
| leaf nsr-oper-down-count { | | |
| type uint32; | | |
| description | | |
| "Number of times NSR scoped sync has been done"; | | |
| } | | |
| leaf last-nsr-scoped-sync { | | |
| type uint32; | | |
| description | | |
| "Last time NSR scoped syncwas done for the | | |
| neighbor"; | | |
| } | | |
| leaf gshut-bandwidth-aware-num-enters { | | |
| type uint32; | | |
| description | | |
| "Number of times neighbor entered | | |
| Graceful-Maintenance due to bandwidth-awareness"; | | |
| } | | |
| leaf gshut-bandwidth-aware-num-exits { | | |
| type uint32; | | |
| description | | |
| "Number of times neighbor exited | | |
| Graceful-Maintenance due to bandwidth-awareness"; | | |
| } | | |
| leaf write-throttles { | | |
| type uint32; | | |
| description | | |
| "Number of write was throttled"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-NOTFNTYPE { | | |
| description | | |
| "BGP NOTFNTYPE"; | | |
| leaf time-since-last-notification { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time since the last notification was sent or | | |
| received (seconds)"; | | |
| } | | |
| leaf notification-error-code { | | |
| type uint8; | | |
| description | | |
| "Error code in last notification"; | | |
| } | | |
| leaf notification-error-subcode { | | |
| type uint8; | | |
| description | | |
| "Error subcode in last notification"; | | |
| } | | |
| list last-notification-data { | | |
| description | | |
| "Message data in last notification"; | | |
| leaf entry { | | |
| type uint8; | | |
| description | | description |
| "Message data in last notification"; | | "Table version # for net"; |
| } | | } |
| } | | leaf table-brib-version { |
| } | | type uint32; |
| | | |
| grouping BGP-NBR-BAG { | | |
| description | | description |
| "BGP Neighbor Information"; | | "Table version # for updates"; |
| container connection-local-address { | | |
| description | | |
| "Local address for the connection"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | } |
| n | container connection-remote-address { | n | leaf advertisedto-pe { |
| | | type boolean; |
| description | | description |
| n | "Remote address for the connection"; | n | "Net could be advertised |
| uses BGP-ADDRTYPE; | | to PE peers"; |
| } | | } |
| n | container send-notification-info { | n | leaf has-local-label { |
| | | type boolean; |
| description | | description |
| n | "Information on the last notification sent"; | n | "Net has local label"; |
| uses BGP-NOTFNTYPE; | | |
| } | | } |
| n | container received-notification-info { | n | leaf net-local-label { |
| description | | |
| "Information on the last notification received"; | | |
| uses BGP-NOTFNTYPE; | | |
| } | | |
| container performance-statistics { | | |
| description | | |
| "BGP neighbor performance statistics"; | | |
| uses BGP-PERF-NBR; | | |
| } | | |
| container message-statistics { | | |
| description | | |
| "BGP neighbor message statistics"; | | |
| uses BGP-NBR-MSG-STATS; | | |
| } | | |
| container tcp-init-sync-time-spec { | | |
| description | | |
| "Time When neighbor entered TCP Init Sync"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container tcp-init-sync-phase-two-time-spec { | | |
| description | | |
| "Time when neighbor entered TCP Init Sync Phase | | |
| Two"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container tcp-init-sync-done-time-spec { | | |
| description | | |
| "Time when neighbor entered TCP Init Sync Done"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container graceful-maintenance { | | |
| description | | |
| "Globally activated BGp neighborfor graceful | | |
| shutdown"; | | |
| uses BGP-NBR-GSHUT; | | |
| } | | |
| container read-throttle-hwm-event { | | |
| description | | |
| "Event for the neighbor when the socket read was | | |
| throttled for the longest duration"; | | |
| uses BGP-NBR-THROTL-STATS-BAG; | | |
| } | | |
| container read-throttle-hwm-event-reset { | | |
| description | | |
| "Event for the neighbor when the socket read was | | |
| throttled for the longest duration before | | |
| session reset"; | | |
| uses BGP-NBR-THROTL-STATS-BAG; | | |
| } | | |
| container write-throttle-hwm-event { | | |
| description | | |
| "Event for the neighbor when the socket write was | | |
| throttled for the longest duration"; | | |
| uses BGP-NBR-THROTL-STATS-BAG; | | |
| } | | |
| container write-throttle-hwm-event-reset { | | |
| description | | |
| "Event for the neighbor when the socket write was | | |
| throttled for the longest duration before | | |
| session reset"; | | |
| uses BGP-NBR-THROTL-STATS-BAG; | | |
| } | | |
| leaf speaker-id { | | |
| type uint8; | | type uint32; |
| description | | |
| "Speaker this neighbor is allocated to"; | | |
| } | | |
| leaf description { | | description |
| type string; | | |
| description | | |
| "BGP neighbor description"; | | |
| } | | |
| leaf local-as { | | |
| type uint32; | | |
| description | | |
| "Local AS number"; | | "Local label"; |
| } | | } |
| n | leaf remote-as { | n | leaf net-local-label-rewrite { |
| type uint32; | | |
| description | | |
| "Remote AS number"; | | |
| } | | |
| leaf has-internal-link { | | |
| type boolean; | | type boolean; |
| description | | description |
| n | "Internal link to neighbor"; | n | "Net label has rewrite"; |
| } | | } |
| n | leaf is-external-neighbor-not-directly-connected { | n | leaf net-local-label-srgb { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate neighbor is external and not | n | "Net label allocated fromSegment routing global |
| directly connected"; | | |
| } | | |
| leaf messages-received { | | |
| type uint32; | | |
| description | | |
| "Number of messages received"; | | |
| } | | |
| leaf messages-sent { | | |
| type uint32; | | |
| description | | |
| "Number of messages sent"; | | |
| } | | |
| leaf update-messages-in { | | |
| type uint32; | | |
| description | | |
| "No. of update msgs received"; | | |
| } | | |
| leaf update-messages-out { | | |
| type uint32; | | |
| description | | |
| "No. of update messages sent"; | | |
| } | | |
| leaf messages-queued-in { | | |
| type uint32; | | |
| description | | |
| "No. of msgs on receive queue"; | | |
| } | | |
| leaf messages-queued-out { | | |
| type uint32; | | |
| description | | |
| "No. of messages on send queue"; | | |
| } | | |
| leaf connection-established-time { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time (in secs) that the connection has been | | |
| established"; | | |
| } | | |
| leaf connection-state { | | |
| type Bgp-conn-state; | | |
| description | | |
| "State of connection"; | | |
| } | | |
| leaf previous-connection-state { | | |
| type Bgp-conn-state; | | |
| description | | |
| "Previous state of connection"; | | |
| } | | |
| leaf connection-admin-status { | | |
| type uint32; | | |
| description | | |
| "Administrative status of connection"; | | |
| } | | |
| leaf open-check-error-code { | | |
| type Bgp-open-check-err; | | |
| description | | |
| "Error code for open check failure forBGP | | |
| neighbor"; | | |
| } | | |
| leaf is-local-address-configured { | | |
| type boolean; | | |
| description | | |
| "Local address configured for the neighbor | | |
| connection"; | | |
| } | | |
| leaf connection-local-port { | | |
| type uint32; | | |
| description | | |
| "Local port for the connection"; | | |
| } | | |
| leaf connection-remote-port { | | |
| type uint32; | | |
| description | | |
| "Remote port for the connection"; | | |
| } | | |
| leaf neighbor-interface-handle { | | |
| type uint32; | | |
| description | | |
| "Interface Handle of Neighbor"; | | |
| } | | |
| leaf reset-notification-sent { | | |
| type boolean; | | |
| description | | |
| "Notification was sent during last reset"; | | |
| } | | |
| leaf is-administratively-shut-down { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if BGP neighbor is | | |
| administratively shut down"; | | |
| } | | |
| leaf is-neighbor-max-prefix-shutdown { | | |
| type boolean; | | |
| description | | |
| "Neighbor shut down because it exceeded max prfx | | |
| count"; | | block"; |
| } | | } |
| n | leaf is-out-of-memory-shutdown { | n | leaf has-lbl-retained { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Neighbor shut down during a SEVERE low memory | n | |
| condition"; | | |
| } | | |
| leaf is-out-of-memory-forced-up { | | |
| type boolean; | | |
| description | | |
| "Neighbor forced up during a low memory condition"; | | |
| } | | |
| leaf is-ebgp-peer-as-league { | | |
| type boolean; | | |
| description | | |
| "EBGP peer belongs to AS League"; | | |
| } | | |
| leaf is-ebgp-peer-common-admin { | | |
| type boolean; | | |
| description | | |
| "EBGP peer with common administation"; | | |
| } | | |
| leaf ttl-security-enabled { | | |
| type boolean; | | |
| description | | |
| "TTL Security enabled"; | | |
| } | | |
| leaf suppress4-byte-as { | | |
| type boolean; | | |
| description | | |
| "Suppress 4byteas capability"; | | |
| } | | |
| leaf bfd-session-state { | | |
| type Bgp-bfd-state; | | |
| description | | |
| "BFD state for this peer"; | | |
| } | | |
| leaf bfd-session-created-state { | | |
| type Bgp-bfd-state; | | |
| description | | |
| "BFD state for this peer"; | | |
| } | | |
| leaf bfd-session-enable-mode { | | |
| type Bgp-bfd-enable-mode; | | |
| description | | |
| "BFD enable mode for this peer"; | | |
| } | | |
| leaf bfd-minintervalval { | | |
| type uint32; | | |
| description | | |
| "BFD Mininterval for this peer"; | | |
| } | | |
| leaf bfd-multiplierval { | | |
| type uint32; | | |
| description | | |
| "BFD Multiplier for this peer"; | | |
| } | | |
| leaf bfd-state-ts { | | |
| type uint64; | | |
| description | | |
| "Timestamp since when nbr is in this bfd state"; | | |
| } | | |
| leaf router-id { | | |
| type inet:ipv4-address; | | |
| description | | |
| "Router ID for the neighbor"; | | |
| } | | |
| leaf negotiated-protocol-version { | | |
| type uint16; | | |
| description | | |
| "Negotiated protocol version with the BGP | | |
| neighbor"; | | |
| } | | |
| leaf ebgp-time-to-live { | | |
| type uint32; | | |
| description | | |
| "Maximum number of hops for external BGP neighbor"; | | |
| } | | |
| leaf is-ebgp-multihop-bgp-mpls-forwarding-disabled { | | |
| type boolean; | | |
| description | | |
| "If true, MPLS and NULL rewrite is disabled; if | | |
| false, it is enabled"; | | |
| } | | |
| leaf tcpmss { | | |
| type uint32; | | |
| description | | |
| "Neighbor TCP Maximum Segment size"; | | |
| } | | |
| leaf tcpmtu { | | |
| type boolean; | | |
| description | | |
| "Neighbor TCP Path Maximum Transmission Unit | | |
| Discovery option"; | | |
| } | | |
| leaf msg-log-in { | | |
| type uint32; | | |
| description | | |
| "Message in log count"; | | |
| } | | |
| leaf msg-log-out { | | |
| type uint32; | | |
| description | | |
| "Message out log count"; | | |
| } | | |
| leaf neighbor-local-as { | | |
| type uint32; | | |
| description | | |
| "Local AS configured on the neighbor"; | | |
| } | | |
| leaf local-as-no-prepend { | | |
| type boolean; | | |
| description | | |
| "Option to not prepend the Local AS to | | |
| announcements"; | | |
| } | | |
| leaf is-capability-negotiation-suppressed { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if Capability negotiation is | | |
| disabled for this BGP neighbor"; | | |
| } | | |
| leaf is-capability-negotiation-performed { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if capability negotiation is | | |
| performed for BGP neighbor"; | | |
| } | | |
| leaf is-route-refresh-capability-received { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if the neighbor supports | | |
| route-refresh was received"; | | |
| } | | |
| leaf is-route-refresh-old-capability-received { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if the neighbor supports | | |
| route-refresh old capability was received"; | | |
| } | | |
| leaf is-gr-aware { | | |
| type boolean; | | |
| description | | |
| "GR awareness received"; | | |
| } | | |
| leaf is4-byte-as-capability-received { | | |
| type boolean; | | |
| description | | |
| "Flag to ndicate if neighbor supports 4-byte AS | | |
| capability received"; | | |
| } | | |
| leaf is4-byte-as-capability-sent { | | |
| type boolean; | | |
| description | | |
| "4-byte AScapability Snt"; | | |
| } | | |
| leaf multi-protocol-capability-received { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if multi-protocol capability | | |
| has been received"; | | "Net has label retained"; |
| } | | } |
| n | leaf hold-time { | n | leaf route-distinguisher { |
| type uint16; | | type xr:Route-dist; |
| units "second"; | | |
| description | | description |
| n | "Hold time (in secs) negotiated for this | n | "Route Distinguisher"; |
| connection"; | | |
| } | | |
| leaf keep-alive-time { | | |
| type uint16; | | |
| units "second"; | | |
| description | | |
| "Keepalive time (in secs) negotiated for this | | |
| connection"; | | |
| } | | |
| leaf configured-hold-time { | | |
| type uint16; | | |
| units "second"; | | |
| description | | |
| "Hold time (in secs) configured for this | | |
| connection"; | | |
| } | | |
| leaf configured-keepalive { | | |
| type uint16; | | |
| units "second"; | | |
| description | | |
| "Keepalive time (in secs) configured for this | | |
| connection"; | | |
| } | | |
| leaf configured-min-acc-hold-time { | | |
| type uint16; | | |
| units "second"; | | |
| description | | |
| "Minimum acceptable hold time from neighbor (in | | |
| secs) configured for this connection"; | | |
| } | | |
| leaf min-advertise-interval { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Minimum advertisement interval, secs part"; | | |
| } | | |
| leaf min-advertise-interval-msecs { | | |
| type uint32; | | |
| units "millisecond"; | | |
| description | | |
| "Minimum advertisement interval, msecs part"; | | |
| } | | |
| leaf min-origination-interval { | | |
| type uint16; | | |
| units "second"; | | |
| description | | |
| "Minimum origination interval (in secs)"; | | |
| } | | |
| leaf connect-retry-interval { | | |
| type uint16; | | |
| units "second"; | | |
| description | | |
| "Time (in secs) for connect retry timer"; | | |
| } | | |
| leaf time-since-last-update { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time (in secs) since last update message was | | |
| received"; | | |
| } | | |
| leaf time-since-last-read { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time (in secs) since last read"; | | |
| } | | |
| leaf time-since-last-read-reset { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time (in secs) since last read before last reset"; | | |
| } | | |
| leaf time-last-cb { | | |
| type uint64; | | |
| description | | |
| "CB"; | | |
| } | | |
| leaf time-last-cb-reset { | | |
| type uint32; | | |
| description | | |
| "Last CB before reset"; | | |
| } | | |
| leaf time-last-fb { | | |
| type uint64; | | |
| description | | |
| "FB"; | | |
| } | | |
| leaf count-last-write { | | |
| type uint32; | | |
| description | | |
| "Count"; | | |
| } | | |
| leaf time-since-last-write { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time (in secs) since last write"; | | |
| } | | |
| leaf attempted-last-write-bytes { | | |
| type uint32; | | |
| description | | |
| "Attempted size of last write"; | | |
| } | | |
| leaf actual-last-write-bytes { | | |
| type uint32; | | |
| description | | |
| "Actual size of last write"; | | |
| } | | |
| leaf time-since-second-last-write { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time (in seconds) elapsed since the second last | | |
| write event"; | | |
| } | | |
| leaf attempted-second-last-write-bytes { | | |
| type uint32; | | |
| description | | |
| "Attempted size of second last write"; | | |
| } | | |
| leaf actual-second-last-write-bytes { | | |
| type uint32; | | |
| description | | |
| "Actual size of second last write"; | | |
| } | | |
| leaf time-since-last-write-reset { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time (in secs) since last write before last | | |
| reset"; | | |
| } | | |
| leaf attempted-last-write-reset-bytes { | | |
| type uint32; | | |
| description | | |
| "Attempted size of last write before reset"; | | |
| } | | |
| leaf actual-last-write-reset-bytes { | | |
| type uint32; | | |
| description | | |
| "Actual size of last write before reset"; | | |
| } | | |
| leaf time-since-second-last-write-reset { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time (in secs) since last write before last | | |
| reset"; | | |
| } | | |
| leaf attempted-second-last-write-reset-bytes { | | |
| type uint32; | | |
| description | | |
| "Attempted size of second last write before reset"; | | |
| } | | |
| leaf actual-second-last-write-reset-bytes { | | |
| type uint32; | | |
| description | | |
| "Actual size of second last write before reset"; | | |
| } | | |
| leaf last-write-event { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time (in secs) since last write thread event"; | | |
| } | | |
| leaf second-last-write-event { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time (in secs) since second last write thread | | |
| event"; | | |
| } | | |
| leaf last-k-aexpiry-reset { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time (in secs) since last KA timer expiry before | | |
| reset"; | | |
| } | | |
| leaf second-last-k-aexpiry-reset { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time (in secs) since second last KA timer expiry | | |
| before reset"; | | |
| } | | |
| leaf last-k-anotsent-reset { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Duration (in secs) since last time that KA was | | |
| not sent before reset"; | | |
| } | | |
| leaf last-k-aerror-reset { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Duration (in secs) since last time that an error | | |
| was encountered after KA expiry"; | | |
| } | | |
| leaf last-k-astart-reset { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time (in secs) since the last KA timer start | | |
| before reset"; | | |
| } | | |
| leaf second-last-k-astart-reset { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time (in secs) since the second last KA timer | | |
| start before reset"; | | |
| } | | |
| leaf connection-up-count { | | |
| type uint32; | | |
| description | | |
| "Number of times the connection was established"; | | |
| } | | |
| leaf connection-down-count { | | |
| type uint32; | | |
| description | | |
| "Number of times connection was dropped"; | | |
| } | | |
| leaf time-since-connection-last-dropped { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time since the connection last went down | | |
| (seconds)"; | | |
| } | | |
| leaf reset-reason { | | |
| type Bgp-reset-reason-index; | | |
| description | | |
| "Reason for last connection reset"; | | |
| } | | |
| leaf peer-reset-reason { | | |
| type Bgp-peer-reset-reason-index; | | |
| description | | |
| "Reason for last peer close event"; | | |
| } | | |
| leaf peer-error-code { | | |
| type uint32; | | |
| description | | |
| "If peer closed, error received from transport"; | | |
| } | | |
| leaf last-notify-error-code { | | |
| type uint8; | | |
| description | | |
| "Code for the last error notification seen on the | | |
| connection"; | | |
| } | | |
| leaf last-notify-error-subcode { | | |
| type uint8; | | |
| description | | |
| "Error subcode of the last error notification | | |
| seen on the connection"; | | |
| } | | |
| leaf error-notifies-received { | | |
| type uint32; | | |
| description | | |
| "Number of error notifications received on the | | |
| connection"; | | |
| } | | |
| leaf error-notifies-sent { | | |
| type uint32; | | |
| description | | |
| "Number of error notifications sent on the | | |
| connection"; | | |
| } | | |
| leaf remote-as-number { | | |
| type uint32; | | |
| description | | |
| "Remote AS number of BGP neighbor"; | | |
| } | | |
| leaf dmz-link-bandwidth { | | |
| type uint32; | | |
| description | | |
| "Bandwidth of link to single-hop eBGP peer"; | | |
| } | | |
| leaf ebgp-recv-dmz { | | |
| type boolean; | | |
| description | | |
| "Receive Bandwidth of link to single-hop eBGP | | |
| peer"; | | |
| } | | |
| leaf ebgp-send-dmz-mode { | | |
| type Bgp-ebgp-send-dmz-enable-mode; | | |
| description | | |
| "Ebgp send dmz link bw mode"; | | |
| } | | |
| leaf tos-type { | | |
| type uint8; | | |
| description | | |
| "Precedence or DSCP type"; | | |
| } | | |
| leaf tos-value { | | |
| type uint8; | | |
| description | | |
| "Precedence or DSCP value"; | | |
| } | | |
| leaf tcp-session-open-mode { | | |
| type Bgp-tcp-mode; | | |
| description | | |
| "The TCP mode to be used to set up BGP session | | |
| with the neighbor"; | | |
| } | | } |
| leaf vrf-name { | | leaf vrf-name { |
| type string; | | type string; |
| description | | description |
| "Name of the VRF"; | | "Name of the VRF"; |
| } | | } |
| n | leaf standby-rp { | n | leaf net-flags { |
| type boolean; | | |
| description | | |
| "Standby RP socket inited for Active Open"; | | |
| } | | |
| leaf nsr-enabled { | | |
| type boolean; | | |
| description | | |
| "Neighbor supports NSR"; | | |
| } | | |
| leaf graceful-restart-enabled-nbr { | | |
| type boolean; | | |
| description | | |
| "Neighbor supports graceful-restart"; | | |
| } | | |
| leaf graceful-restart-helper-mode { | | |
| type boolean; | | |
| description | | |
| "Neighbor supports graceful-restart in | | |
| helper-mode"; | | |
| } | | |
| leaf gr-restart-time { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Neighbor restart time (in seconds)"; | | |
| } | | |
| leaf gr-stale-path-time { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Neighbor stale-path time (in seconds)"; | | |
| } | | |
| leaf fssn-offset { | | |
| type uint32; | | |
| description | | |
| "First standby SeqNo offset"; | | |
| } | | |
| leaf fpbsn-offset { | | |
| type uint32; | | |
| description | | |
| "First standby PDU boundary SeqNo offset"; | | |
| } | | |
| leaf last-ackd-seq-no { | | |
| type uint32; | | |
| description | | |
| "SeqNo of the last Ackd byte"; | | |
| } | | |
| leaf bytes-written { | | |
| type uint32; | | |
| units "byte"; | | |
| description | | |
| "Total bytes written by write thread"; | | |
| } | | |
| leaf bytes-read { | | |
| type uint32; | | |
| units "byte"; | | |
| description | | |
| "Total bytes read"; | | |
| } | | |
| leaf socket-read-bytes { | | |
| type uint32; | | |
| units "byte"; | | |
| description | | |
| "Total read bytes value insocket-lib"; | | |
| } | | |
| leaf is-read-disabled { | | |
| type boolean; | | |
| description | | |
| "If true, socket read isdisabled"; | | |
| } | | |
| leaf update-bytes-read { | | |
| type uint32; | | |
| units "byte"; | | |
| description | | |
| "Total number of bytes readcorresponding to | | |
| update messages"; | | |
| } | | |
| leaf nsr-state { | | |
| type Bgp-sync-nbr-nsr-state; | | |
| description | | |
| "NSR state"; | | |
| } | | |
| leaf is-passive-close { | | |
| type boolean; | | |
| description | | |
| "If true, active socket canbe closed if passive | | |
| openis received for a GRcapable neighbor"; | | |
| } | | |
| leaf nbr-enforce-first-as { | | |
| type boolean; | | |
| description | | |
| "Neighbor enforce first AS"; | | |
| } | | |
| leaf active-bmp-servers { | | |
| type uint8; | | |
| description | | |
| "BMP Servers to which the neighbor sends logs"; | | |
| } | | |
| leaf nbr-cluster-id { | | |
| type uint32; | | |
| description | | |
| "Cluster id"; | | |
| } | | |
| leaf nbr-in-cluster { | | |
| type uint8; | | |
| description | | |
| "Type of cluster_id:undefined/number/Ip address"; | | |
| } | | |
| leaf ignore-connected { | | |
| type boolean; | | |
| description | | |
| "If true, the VPN client isan IBGP CE peer"; | | |
| } | | |
| leaf internal-vpn-client { | | |
| type boolean; | | |
| description | | |
| "If true, don't do NHconnected check for nbr"; | | |
| } | | |
| leaf io-armed { | | |
| type boolean; | | |
| description | | |
| "If true, socket has beenauto-armed for io | | |
| control"; | | |
| } | | |
| leaf read-armed { | | |
| type boolean; | | |
| description | | |
| "If true, socket has beenauto-armed for read"; | | |
| } | | |
| leaf write-armed { | | |
| type boolean; | | |
| description | | |
| "If true, socket has beenauto-armed for write"; | | |
| } | | |
| leaf discard-data-bytes { | | |
| type uint32; | | |
| units "byte"; | | |
| description | | |
| "Remaining discard data (bytes) on Standby"; | | |
| } | | |
| leaf local-as-replace-as { | | |
| type boolean; | | |
| description | | |
| "Local AS Replace-AS option"; | | |
| } | | |
| leaf local-as-dual-as { | | |
| type boolean; | | |
| description | | |
| "Local AS Dual-AS option"; | | |
| } | | |
| leaf local-as-dual-as-mode-native { | | |
| type boolean; | | |
| description | | |
| "Applies only if Local AS Dual-AS option is | | |
| enabled. Indicates if Dual-AS mode is native."; | | |
| } | | |
| leaf egress-peer-engineering-enabled { | | |
| type boolean; | | |
| description | | |
| "Indicates if Egress Peer Engineering is enabled"; | | |
| } | | |
| leaf last-insert-reset-queue { | | |
| type uint64; | | |
| description | | |
| "Time when this neighbor was last inserted in | | |
| reset queue"; | | |
| } | | |
| leaf last-remove-reset-queue { | | |
| type uint64; | | |
| description | | |
| "Time when this neighbor was last removed from | | |
| reset queue"; | | |
| } | | |
| leaf discard-as4-path { | | |
| type uint32; | | |
| description | | |
| "Discard AS4_PATH in case there is a discrepancy | | |
| in merging AS_PATH and AS4_PATH,retain ASPATH"; | | |
| } | | |
| leaf rpki-disable { | | |
| type boolean; | | |
| description | | |
| "Prefix validation disabled"; | | |
| } | | |
| leaf rpki-use-validity { | | |
| type boolean; | | |
| description | | |
| "Prefix v. use validity"; | | |
| } | | |
| leaf rpki-allow-invalid { | | |
| type boolean; | | |
| description | | |
| "Prefix v. allow invalid"; | | |
| } | | |
| leaf rpki-signal-ibgp { | | |
| type boolean; | | |
| description | | |
| "Prefix v. signal ibgp"; | | |
| } | | |
| leaf dynamic-neighbor { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if the neighbor specifically | | |
| defining the neighborsis a dynamic neighbor"; | | |
| } | | |
| leaf merge-inbound-safi1and4-updates { | | |
| type boolean; | | |
| description | | |
| "Merge SAFI-1 and SAFI-4 updates from neighbor"; | | |
| } | | |
| leaf is-capability-enhe-suppressed { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if Capability | | |
| extended-nexthop-encoding is disabled for this | | |
| BGP neighbor"; | | |
| } | | |
| leaf delete-time-remaining { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time (in secs) remaining for deletion"; | | |
| } | | |
| leaf sn-bfd-discriminator { | | |
| type uint32; | | |
| description | | |
| "Local Discriminator for the associated BFD | | |
| session"; | | |
| } | | |
| leaf log-up-down-configured { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if the log neighbor Up/Down is | | |
| specifically enabled"; | | |
| } | | |
| leaf log-up-down-disabled { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if the log neighbor Up/Down is | | |
| specifically disabled"; | | |
| } | | |
| leaf bmp-server-id { | | |
| type int32; | | type uint32; |
| description | | description |
| n | "BMP Server id"; | n | "Flags associated with |
| | | net"; |
| } | | } |
| n | leaf last-bgp-received-message { | n | leaf net-extended-flags { |
| type Bgp-message; | | |
| description | | |
| "Last BGP message received from the neighbor"; | | |
| } | | |
| leaf maximum-prefix-restart-time { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Max Prefix Restart timer (in seconds)"; | | |
| } | | |
| leaf connected-interface { | | |
| type uint32; | | |
| description | | |
| "Connected interface Handle of neighbor"; | | |
| } | | |
| leaf interface-added-in-lpts { | | |
| type uint32; | | |
| description | | |
| "Interface Handle programmed in LPTS for neighbor"; | | |
| } | | |
| leaf evpn-link-bandwidth-enabled { | | |
| type boolean; | | |
| description | | |
| "EVPN Link Bandwidth Enabled"; | | |
| } | | |
| leaf evpn-link-bandwidth-type { | | |
| type Bgp-evpn-link-bw-edm; | | |
| description | | |
| "EVPN Link Bandwidth Value-Unit Type"; | | |
| } | | |
| leaf evpn-link-bandwidth-weight { | | |
| type uint32; | | |
| description | | |
| "EVPN Link Bandwidth Value-Weight"; | | |
| } | | |
| leaf upd-errh-noreset { | | |
| type boolean; | | |
| description | | |
| "Update error handling configuration for C1 | | |
| category errors"; | | |
| } | | |
| leaf upd-errh-treat-as-withdraw { | | |
| type boolean; | | |
| description | | |
| "Update error handling configuration for | | |
| treat-as-withdrawerrors"; | | |
| } | | |
| leaf sync-ilist-element-flag { | | |
| type int32; | | type uint32; |
| description | | |
| "Neighbor Sync Ilist Element Flag"; | | |
| } | | |
| leaf allow-as-in { | | |
| type uint32; | | |
| description | | |
| "Number of Own AS numbers allowed in inbound | | |
| update"; | | |
| } | | |
| leaf sent-community-to-neighbor { | | |
| type boolean; | | |
| description | | |
| "Community attribute sent to neighbor"; | | |
| } | | |
| leaf sn-extcommunity { | | |
| type boolean; | | |
| description | | |
| "Extended communityattribute sent to neighbor"; | | |
| } | | |
| leaf dampening { | | |
| type Bgp-nbr-dampening; | | |
| description | | |
| "dampening configuration for neighbor"; | | |
| } | | |
| leaf is-as-override-disabled { | | |
| type Bgp-nbr-aspath-as-override; | | |
| description | | |
| "Disable as override"; | | |
| } | | |
| leaf nbr-disable-peer-as { | | |
| type Bgp-nbr-disable-peer-as; | | |
| description | | |
| "NBR Disable Peer AS"; | | |
| } | | |
| leaf gbl-disable-peer-as-enable { | | |
| type boolean; | | |
| description | | |
| "Global Disable Peer AS Enable"; | | |
| } | | |
| leaf hold-time-low-threshold-percent { | | |
| type uint8; | | |
| units "percentage"; | | |
| description | | |
| "Low threshold as percentage of Hold Time for | | |
| monitoring"; | | |
| } | | |
| leaf hold-time-high-threshold-percent { | | |
| type uint8; | | |
| units "percentage"; | | |
| description | | |
| "High threshold as percentage of Hold Time for | | |
| monitoring"; | | |
| } | | |
| leaf longest-elapsed-hold-timer { | | |
| type uint32; | | |
| description | | |
| "Longest elapsed hold time period (in msec) | | |
| recorded"; | | |
| } | | |
| leaf longest-elapsed-hold-timer-time { | | |
| type uint64; | | |
| description | | |
| "Time when the longest elapsed hold time period | | |
| was recorded"; | | |
| } | | |
| leaf hold-time-low-threshold-exceed-count { | | |
| type uint32; | | |
| description | | |
| "Number of times the elapsed hold time crossed | | |
| the low threshold"; | | |
| } | | |
| leaf hold-time-high-threshold-exceed-count { | | |
| type uint32; | | |
| description | | |
| "Number of times the elapsed hold time crossed | | |
| the high threshold"; | | |
| } | | |
| leaf longest-elapsed-hold-timer-reset { | | |
| type uint32; | | |
| description | | |
| "Longest elapsed hold time period (in msec) | | |
| recorded before last session reset"; | | |
| } | | |
| leaf longest-elapsed-hold-timer-time-reset { | | |
| type uint64; | | |
| description | | |
| "Time when the longest elapsed hold time period | | |
| was recorded before last session reset"; | | |
| } | | |
| leaf hold-time-low-threshold-exceed-reset-count { | | |
| type uint32; | | |
| description | | |
| "Number of times the elapsed hold time crossed | | |
| the low threshold before last session reset"; | | |
| } | | |
| leaf hold-time-high-threshold-exceed-reset-count { | | |
| type uint32; | | |
| description | | |
| "Number of times the elapsed hold time crossed | | |
| the high threshold before last session reset"; | | |
| } | | |
| leaf first-msg-read-time { | | |
| type uint64; | | |
| description | | |
| "Time when the first message was read from the | | |
| neighbor after up or after switchover in since | | |
| epoch"; | | |
| } | | |
| leaf first-msg-write-time { | | |
| type uint64; | | |
| description | | |
| "Time when the first message was written to the | | |
| neighbor after up or after switchover in nsec | | |
| since epoch"; | | |
| } | | |
| leaf first-msg-read-time-reset { | | |
| type uint64; | | |
| description | | |
| "Time when the first message was read from the | | |
| neighbor after up or after switchover before | | |
| last session reset in nsec since epoch"; | | |
| } | | |
| leaf first-msg-write-time-reset { | | |
| type uint64; | | |
| description | | |
| "Time when the first message was written to the | | |
| neighbor after up or after switchover before | | |
| last session reset in nsec since epoch"; | | |
| } | | |
| leaf nbr-fast-fallover { | | |
| type boolean; | | |
| description | | |
| "BGP neighbor will go down if its directly | | |
| connected interface goes down"; | | |
| } | | |
| leaf fast-ext-fallover { | | |
| type boolean; | | |
| description | | |
| "VRF level fast external fallover"; | | |
| } | | |
| leaf nbr-directly-connected { | | |
| type boolean; | | |
| description | | |
| "Neighbor is directly connected"; | | |
| } | | |
| leaf control-packets-on-ip { | | |
| type boolean; | | |
| description | | |
| "Prefer to send BGP control packets on IP"; | | |
| } | | |
| leaf skip-read-count { | | |
| type uint32; | | |
| description | | |
| "Skip Read count"; | | |
| } | | |
| list af-data { | | |
| key "af-name"; | | |
| max-elements "25"; | | |
| description | | |
| "Address family specific neighbor data"; | | |
| uses BGP-NBR-AF; | | |
| } | | |
| list version-bump-count { | | |
| description | | |
| "Total version bumps per event for all AFIs"; | | |
| uses NBR-TOTAL-BUMPS; | | |
| } | | |
| list version-rate-stat { | | |
| max-elements "4"; | | |
| description | | |
| "Version bump stats per event per interval for | | |
| all AFIs"; | | |
| uses NBR-VER-RATE-DETAIL; | | |
| } | | |
| list read-throttle-event { | | |
| description | | |
| "List of the recent events for the neighbor where | | |
| socket read was throttled"; | | |
| uses BGP-NBR-THROTL-STATS-BAG; | | |
| } | | |
| list read-throttle-events-reset { | | |
| description | | |
| "List of the recent events for the neighbor where | | |
| socket read was throttled before session reset"; | | |
| uses BGP-NBR-THROTL-STATS-BAG; | | |
| } | | |
| list write-throttle-event { | | |
| description | | |
| "List of the recent events for the neighbor where | | |
| socket write was throttled"; | | |
| uses BGP-NBR-THROTL-STATS-BAG; | | |
| } | | |
| list write-throttle-events-reset { | | |
| description | | |
| "List of the recent events for the neighbor where | | |
| socket write was throttled before session reset"; | | |
| uses BGP-NBR-THROTL-STATS-BAG; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-PATH-MULTI { | | |
| description | | |
| "BGP path set"; | | |
| list paths { | | |
| description | | |
| "BGP paths information"; | | |
| uses BGP-PATH-BAG; | | |
| } | | |
| list adv-path-info { | | |
| description | | |
| "Net Advertized Paths"; | | |
| uses BGP-PATH-ADV-BAG; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-ORR-GROUP-BAG { | | |
| description | | |
| "BGP ORR Group Information"; | | |
| container orr-root-address { | | |
| description | | |
| "ORR Root Address"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| container orr-sec-root-address { | | |
| description | | |
| "ORR Sec Root Address"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| container orr-ter-root-address { | | |
| description | | |
| "ORR ter Root Address"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| leaf orr-group-name { | | |
| type string; | | |
| description | | |
| "ORR Group Name"; | | |
| } | | |
| leaf is-orr-root-address-configured { | | |
| type boolean; | | |
| description | | |
| "ORR Root address configured"; | | |
| } | | |
| leaf is-orr-sec-root-address-configured { | | |
| type boolean; | | |
| description | | |
| "ORR Sec Root address configured"; | | |
| } | | |
| leaf is-orr-ter-root-address-configured { | | |
| type boolean; | | |
| description | | |
| "ORR Ter Root address configured"; | | |
| } | | |
| leaf orr-neighbor-count { | | |
| type uint32; | | |
| description | | |
| "ORR neighbor count"; | | |
| } | | |
| leaf orr-index { | | |
| type uint32; | | |
| description | | |
| "ORR index"; | | |
| } | | |
| leaf orr-tableid { | | |
| type uint32; | | |
| description | | |
| "ORR Group tableid"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-NBR-ADV-CNT-BAG { | | |
| description | | |
| "BGP Neighbor adv cnt bag"; | | |
| leaf max-prefix-advertisedcount { | | |
| type uint32; | | |
| description | | |
| "Number of prefixes advertsied to neighbor"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-RECENT-NET-BAG { | | |
| description | | |
| "BGP Recent Net"; | | |
| container bgp-prefix { | | |
| description | | |
| "BGP prefix"; | | |
| uses BGP-PREFIXTYPE; | | |
| } | | |
| leaf route-distinguisher { | | |
| type xr:Route-dist; | | |
| description | | |
| "BGP path Route Distinguisher"; | | |
| } | | |
| leaf af-name { | | |
| type Bgp-afi; | | |
| description | | |
| "Address family identifier"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-MVPN-EXTCOMM { | | |
| description | | |
| "MVPN RT list entry"; | | |
| list bgp-mvpn-extcomm { | | |
| description | | |
| "Next entry in prefix list"; | | |
| leaf ext-comm-value { | | |
| type yang:hex-string; | | |
| description | | description |
| "Extended community value"; | | "Net extended flags"; |
| } | | } |
| leaf ext-comm-is-stale { | | leaf net-multipath { |
| type boolean; | | type boolean; |
| description | | description |
| "Extended community is stale"; | | "Net has multipaths"; |
| } | | } |
| } | | leaf net-eibgp-multipath { |
| } | | type boolean; |
| | | |
| grouping BGP-MVPN-RT-LIST-BAG { | | |
| description | | description |
| "BGP MVPN RT list bag"; | | "Net has EIBGP multipaths"; |
| container mvpn-extcomm-list { | | |
| description | | |
| "Prefix list"; | | |
| uses BGP-MVPN-EXTCOMM; | | |
| } | | |
| leaf af-name { | | |
| type Bgp-afi; | | |
| description | | |
| "Address family identfier"; | | |
| } | | |
| leaf vrf-ri-exist { | | |
| type boolean; | | |
| description | | |
| "Is Vrf ri existing"; | | |
| } | | |
| leaf router-address { | | |
| type inet:ipv4-address; | | |
| description | | |
| "PE address"; | | |
| } | | |
| leaf vrf-index { | | |
| type uint16; | | |
| description | | |
| "Vrf index"; | | |
| } | | |
| leaf seg-nh-exist { | | |
| type boolean; | | |
| description | | |
| "Is segmented nh existing"; | | |
| } | | |
| leaf seg-nh-address { | | |
| type inet:ipv4-address; | | |
| description | | |
| "Segmented nexthop"; | | |
| } | | |
| leaf source-as-exist { | | |
| type boolean; | | |
| description | | |
| "Is source as exising"; | | |
| } | | |
| leaf source-as { | | |
| type uint32; | | |
| description | | |
| "Source As number"; | | |
| } | | |
| leaf vrf-ri-exist-m { | | |
| type boolean; | | |
| description | | |
| "Is Vrf ri existing for mcast"; | | |
| } | | |
| leaf router-address-m { | | |
| type inet:ipv4-address; | | |
| description | | |
| "PE address for mcast"; | | |
| } | | |
| leaf vrf-index-m { | | |
| type uint16; | | |
| description | | |
| "Vrf index for mcast"; | | |
| } | | |
| leaf seg-nh-exist-m { | | |
| type boolean; | | |
| description | | |
| "Is segmented nh existing for mcast"; | | |
| } | | |
| leaf seg-nh-address-m { | | |
| type inet:ipv4-address; | | |
| description | | |
| "Segmented nexthop for mcast"; | | |
| } | | |
| leaf source-as-exist-m { | | |
| type boolean; | | |
| description | | |
| "Is source as exising for mcast"; | | |
| } | | |
| leaf source-as-m { | | |
| type uint32; | | |
| description | | |
| "Source As number for mcast"; | | |
| } | | |
| leaf connector-src-exist { | | |
| type boolean; | | |
| description | | |
| "Is Connector src existing"; | | |
| } | | |
| leaf connector-src { | | |
| type inet:ipv4-address; | | |
| description | | |
| "Connector src"; | | |
| } | | |
| } | | } |
| | | leaf net-backup-available { |
| grouping BGP-PATH-ELEM-BAG { | | type boolean; |
| description | | description |
| "BGP path element"; | | "Net has backup path"; |
| container pelem-path-nexthop { | | |
| description | | |
| "Path nexthop address"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | } |
| n | container nh-tunnel { | n | leaf net-backup-label-rewrite-available { |
| | | type boolean; |
| description | | description |
| n | "NH tunnel information"; | n | "Net has label rewrite for backup path"; |
| uses BGP-TE-TUNNEL; | | |
| } | | } |
| n | container pelem-path-neighbor-addr { | n | leaf rib-failed { |
| | | type boolean; |
| description | | description |
| n | "Path neighbor address"; | n | "RIB install failed"; |
| uses BGP-ADDRTYPE; | | |
| } | | } |
| n | leaf pelem-path-id { | n | leaf gateway-array { |
| type uint32; | | |
| description | | |
| "Local Path ID"; | | |
| } | | |
| leaf pelem-version { | | |
| type uint64; | | type uint32; |
| | | description |
| | | "Gateway array ID"; |
| | | } |
| | | leaf resilient-nexthop-set { |
| | | type uint32; |
| | | description |
| | | "Resilient nexthop set ID"; |
| | | } |
| | | leaf is-permanent-network { |
| | | type boolean; |
| | | description |
| | | "Permanent Network"; |
| | | } |
| | | leaf num-of-path { |
| | | type uint32; |
| | | description |
| | | "Number of path for this net"; |
| | | } |
| | | leaf version { |
| | | type uint32; |
| description | | description |
| "Version"; | | "Version"; |
| n | } | n | |
| leaf pelem-flags { | | |
| type uint32; | | |
| description | | |
| "Flags"; | | |
| } | | |
| leaf pelem-gw-metric { | | |
| type uint32; | | |
| description | | |
| "Gateway metric"; | | |
| } | | |
| leaf pelem-path-flags { | | |
| type uint64; | | |
| description | | |
| "Path flags"; | | |
| } | | |
| leaf pelem-path-peer-path-id { | | |
| type uint32; | | |
| description | | |
| "Path peer path ID"; | | |
| } | | |
| leaf pelem-table-attr-version { | | |
| type uint64; | | |
| description | | |
| "Table Attr version"; | | |
| } | | |
| leaf pelem-path-table-attr-version { | | |
| type uint64; | | |
| description | | |
| "Path Table Attribute version"; | | |
| } | | |
| leaf pelem-no-bestpath-table-attr-version { | | |
| type uint64; | | |
| description | | |
| "BGP network no best path tableattribute version | | |
| number"; | | |
| } | | |
| leaf pelem-no-addpath-table-attr-version { | | |
| type uint64; | | |
| description | | |
| "The version of the no addpath table attribute"; | | |
| } | | |
| leaf is-perm-path-pelem { | | |
| type boolean; | | |
| description | | |
| "Pelem for permanent path"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-NET-BAG { | | |
| description | | |
| "BGP network"; | | |
| container bgp-prefix { | | |
| description | | |
| "BGP prefix"; | | |
| uses BGP-PREFIXTYPE; | | |
| } | | |
| container version-timestamp { | | |
| description | | |
| "BGP network version timestamp"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container version-age { | | |
| description | | |
| "BGP network age of version"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container delayed-timestamp { | | |
| description | | |
| "BGP network last delayed timestamp"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| leaf af-name { | | |
| type Bgp-afi; | | |
| description | | |
| "Address family identifier"; | | |
| } | | |
| leaf process-instance-id { | | |
| type uint8; | | |
| description | | |
| "ID of the BGP process instance"; | | |
| } | | |
| leaf has-inconsistent-paths { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if inconsistent paths attached | | |
| to net"; | | |
| } | | |
| leaf is-net-aggregation-suppressed { | | |
| type boolean; | | |
| description | | |
| "Net suppressed due to aggregation"; | | |
| } | | |
| leaf is-net-aggregate-contributor { | | |
| type boolean; | | |
| description | | |
| "Net is an aggregate contributor"; | | |
| } | | |
| leaf is-net-ldp-signaled { | | |
| type boolean; | | |
| description | | |
| "L2VPN Net LDP signaled aggregation"; | | |
| } | | |
| leaf table-version { | | |
| type uint64; | | |
| description | | |
| "Table version # for net"; | | |
| } | | |
| leaf table-brib-version { | | |
| type uint64; | | |
| description | | |
| "Table version # for updates"; | | |
| } | | |
| leaf advertisedto-pe { | | |
| type boolean; | | |
| description | | |
| "Net could be advertised to PE peers"; | | |
| } | | |
| leaf has-local-label { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if local BGP labelassociated | | |
| with the net"; | | |
| } | | |
| leaf net-local-label { | | |
| type uint32; | | |
| description | | |
| "Local label"; | | |
| } | | |
| leaf net-label-mode { | | |
| type uint32; | | |
| description | | |
| "Label mode"; | | |
| } | | |
| leaf net-local-label-rewrite { | | |
| type boolean; | | |
| description | | |
| "Net label has rewrite"; | | |
| } | | |
| leaf net-local-label-srgb { | | |
| type boolean; | | |
| description | | |
| "Net label allocated fromSegment routing global | | |
| block"; | | |
| } | | |
| leaf has-lbl-retained { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if BGP network labels are | | |
| retained "; | | |
| } | | |
| leaf route-distinguisher { | | |
| type xr:Route-dist; | | |
| description | | |
| "BGP network Route Distinguisher"; | | |
| } | | |
| leaf vrf-name { | | |
| type string; | | |
| description | | |
| "Name of the VRF"; | | |
| } | | |
| leaf net-flags { | | |
| type uint32; | | |
| description | | |
| "Flags associated with net"; | | |
| } | | |
| leaf net-extended-flags { | | |
| type uint32; | | |
| description | | |
| "BGP network flags for extendedcommunity"; | | |
| } | | |
| leaf net-multipath { | | |
| type boolean; | | |
| description | | |
| "Net has multipaths"; | | |
| } | | |
| leaf net-eibgp-multipath { | | |
| type boolean; | | |
| description | | |
| "Net has EIBGP multipaths"; | | |
| } | | |
| leaf net-backup-available { | | |
| type boolean; | | |
| description | | |
| "Net has backup path"; | | |
| } | | |
| leaf net-backup-label-rewrite-available { | | |
| type boolean; | | |
| description | | |
| "Net has label rewrite for backup path"; | | |
| } | | |
| leaf rib-failed { | | |
| type boolean; | | |
| description | | |
| "RIB install failed"; | | |
| } | | |
| leaf gateway-array { | | |
| type uint32; | | |
| description | | |
| "ID for the gateway array"; | | |
| } | | |
| leaf resilient-nexthop-set { | | |
| type uint32; | | |
| description | | |
| "ID for the Resilient per CEnexthop set"; | | |
| } | | |
| leaf is-permanent-network { | | |
| type boolean; | | |
| description | | |
| "Flag that indicates that the networkhas | | |
| permanent path"; | | |
| } | | |
| leaf num-of-path { | | |
| type uint32; | | |
| description | | |
| "Number of path for this net"; | | |
| } | | |
| leaf version { | | |
| type uint64; | | |
| description | | |
| "The version of the the radix tree"; | | |
| } | | } |
| leaf bit { | | leaf bit { |
| type uint16; | | type uint16; |
| description | | description |
| "Bit"; | | "Bit"; |
| } | | } |
| leaf flags { | | leaf flags { |
| type uint8; | | type uint8; |
| description | | description |
| "Flags"; | | "Flags"; |
| } | | } |
| n | leaf has-srv6-sid-allocated { | n | leaf has-s-rv6sid-allocated { |
| type boolean; | | type boolean; |
| description | | description |
| "Net has SRv6 SID allocated"; | | "Net has SRv6 SID allocated"; |
| } | | } |
| n | leaf srv6-sid-address { | n | leaf srv6sid-address { |
| type Ipv6-address; | | type Ipv6-address; |
| description | | description |
| "SRv6 SID address value"; | | "SRv6 SID address value"; |
| } | | } |
| n | leaf srv6-sid-address-len { | n | leaf srv6sid-address-len { |
| type uint32; | | type uint32; |
| description | | description |
| "SRv6 SID address Length"; | | "SRv6 SID address Length"; |
| n | } | n | |
| leaf srv6-sid-format { | | |
| type uint32; | | |
| description | | |
| "SRv6 SID address Format"; | | |
| } | | |
| leaf secondary-label { | | |
| type uint32; | | |
| description | | |
| "Secondary label"; | | |
| } | | |
| leaf backup-gateway-array { | | |
| type uint32; | | |
| description | | |
| "ID for the backup gateway array"; | | |
| } | | |
| leaf backup-resilient-nexthop-set { | | |
| type uint32; | | |
| description | | |
| "ID for the backup Resilientper CE"; | | |
| } | | |
| leaf net-additional-flags { | | |
| type uint32; | | |
| description | | |
| "Additional flags for BGP network"; | | |
| } | | |
| leaf srv6-alloc-mode { | | |
| type uint32; | | |
| description | | |
| "SRv6 alloc mode"; | | |
| } | | |
| leaf srv6-locator-id { | | |
| type uint32; | | |
| description | | |
| "SRv6 Locator ID"; | | |
| } | | } |
| list local-peers-advertised-to { | | list local-peers-advertised-to { |
| description | | description |
| "Local peers that this prefix has been advertised | | "Local peers that this prefix has been advertised |
| to"; | | to"; |
| uses BGP-ADVINFO-TYPE; | | uses BGP-ADVINFO-TYPE; |
| } | | } |
| list pe-peers-advertised-to { | | list pe-peers-advertised-to { |
| description | | description |
| "PE peers that this prefix has been advertised to"; | | "PE peers that this prefix has been advertised to"; |
| uses BGP-ADVINFO-TYPE; | | uses BGP-ADVINFO-TYPE; |
| } | | } |
| n | list best-path-orrbitfield { | n | list best-path-orr-bitfield { |
| description | | description |
| "ORR Best path Bitfields"; | | "ORR Best path Bitfields"; |
| uses BGP-ADVINFO-TYPE; | | uses BGP-ADVINFO-TYPE; |
| } | | } |
| n | list add-path-orrbitfield { | n | list add-path-orr-bitfield { |
| description | | description |
| "ORR Add path Bitfields"; | | "ORR Add path Bitfields"; |
| uses BGP-ADVINFO-TYPE; | | uses BGP-ADVINFO-TYPE; |
| } | | } |
| list local-process-instance-path { | | list local-process-instance-path { |
| description | | description |
| "Local (to process instance) paths for this net "; | | "Local (to process instance) paths for this net "; |
| uses BGP-PATH-BAG; | | uses BGP-PATH-BAG; |
| } | | } |
| list active-process-instance-path { | | list active-process-instance-path { |
| description | | description |
| n | "Path for this net from BGP active instance | n | "Active's paths for this net "; |
| process"; | | |
| uses BGP-PATH-BAG; | | uses BGP-PATH-BAG; |
| } | | } |
| list local-path-element { | | list local-path-element { |
| description | | description |
| n | "BGP network elements list of thelocal path"; | n | "Local path element list"; |
| uses BGP-PATH-ELEM-BAG; | | uses BGP-PATH-ELEM-BAG; |
| } | | } |
| list active-path-element { | | list active-path-element { |
| description | | description |
| "Path element list received from Active inst"; | | "Path element list received from Active inst"; |
| uses BGP-PATH-ELEM-BAG; | | uses BGP-PATH-ELEM-BAG; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPDGEN-FILTERGRP-BAG { | | grouping BGP-UPDGEN-FILTERGRP-BAG { |
| description | | description |
| "BGP Update generation Filter-group information"; | | "BGP Update generation Filter-group information"; |
| leaf process-id { | | leaf process-id { |
| type uint32; | | type uint32; |
| description | | description |
| "ProcessID"; | | "ProcessID"; |
| } | | } |
| leaf update-vrf-name { | | leaf update-vrf-name { |
| type string; | | type string; |
| description | | description |
| "VRF Name"; | | "VRF Name"; |
| } | | } |
| leaf update-group-af-name { | | leaf update-group-af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Address family identifier"; | | "Address family identifier"; |
| } | | } |
| leaf update-filter-group-index { | | leaf update-filter-group-index { |
| type uint32; | | type uint32; |
| description | | description |
| "Filter-group index"; | | "Filter-group index"; |
| } | | } |
| leaf parent-filter-group-index { | | leaf parent-filter-group-index { |
| type uint32; | | type uint32; |
| description | | description |
| n | "In refresh sub group points to the | n | "Parent Filter-group index"; |
| correspondingfilter group in parent subgroup | | |
| index"; | | |
| } | | } |
| leaf sub-group-index-xr { | | leaf sub-group-index-xr { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Index for the sub-group used when accessing bits"; | n | "Sub-group index"; |
| } | | } |
| leaf sub-group-id-xr { | | leaf sub-group-id-xr { |
| type uint32; | | type uint32; |
| description | | description |
| "Sub-group identifier"; | | "Sub-group identifier"; |
| } | | } |
| leaf parent-sub-group-index { | | leaf parent-sub-group-index { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Index for the subgroup of parent"; | n | "Parent Sub-group index"; |
| } | | } |
| leaf parent-sub-group-id { | | leaf parent-sub-group-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Parent Sub-group identifier"; | | "Parent Sub-group identifier"; |
| } | | } |
| leaf update-group-index-xr { | | leaf update-group-index-xr { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP update generation index of update-group"; | n | "Update-group index"; |
| } | | } |
| leaf neighbor-count { | | leaf neighbor-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of neighbors in this BGP filter-group"; | n | "Neighbor count"; |
| } | | |
| } | | |
| | | |
| grouping BGP-BMP-CONVERGENCE-LOCALRIB { | | |
| description | | |
| "BGP BMP CONVERGENCE LOCALRIB"; | | |
| leaf is-update-gen-pending { | | |
| type boolean; | | |
| description | | |
| "Flag indicating if update generation is pending"; | | |
| } | | |
| leaf table-version { | | |
| type uint64; | | |
| description | | |
| "BMP table version"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-BMP-CONVERGENCE-INPOSTPOL { | | |
| description | | |
| "BGP BMP CONVERGENCE INPOSTPOL"; | | |
| leaf is-update-gen-pending { | | |
| type boolean; | | |
| description | | |
| "Flag indicating if update generation is pending"; | | |
| } | | |
| leaf is-table-copy-pending { | | |
| type boolean; | | |
| description | | |
| "Flag indicating if table copy is pending"; | | |
| } | | |
| leaf table-version { | | |
| type uint64; | | |
| description | | |
| "BMP table version"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-BMP-CONVERGENCE-INPREPOL { | | |
| description | | |
| "BGP BMP CONVERGENCE INPREPOL"; | | |
| leaf is-route-refresh-sent { | | |
| type boolean; | | |
| description | | |
| "Flag indicating if route refresh is sent"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-BMP-CONVERGENCE-MODE { | | |
| description | | |
| "BMP mode info"; | | |
| container inbound-pre-policy-information { | | |
| when "../mode = 'inbound-pre-policy'" { | | |
| description | | |
| "../Mode = 'InboundPrePolicy'"; | | |
| } | | |
| description | | |
| "Inbound Pre Policy Information"; | | |
| uses BGP-BMP-CONVERGENCE-INPREPOL; | | |
| } | | |
| container inbound-post-policy-information { | | |
| when "../mode = 'inbound-post-policy'" { | | |
| description | | |
| "../Mode = 'InboundPostPolicy'"; | | |
| } | | |
| description | | |
| "Inbound Post Policy Information"; | | |
| uses BGP-BMP-CONVERGENCE-INPOSTPOL; | | |
| } | | |
| container local-rib-information { | | |
| when "../mode = 'local-rib'" { | | |
| description | | |
| "../Mode = 'LocalRib'"; | | |
| } | | |
| description | | |
| "Local RIB Information"; | | |
| uses BGP-BMP-CONVERGENCE-LOCALRIB; | | |
| } | | |
| leaf mode { | | |
| type Bgp-bmp-mode; | | |
| description | | |
| "Mode"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-BMP-CONVERGENCE-PER-SERVER { | | |
| description | | |
| "BMP Per server convergence information"; | | |
| leaf bmp-server-name { | | |
| type string; | | |
| description | | |
| "BMP server name"; | | |
| } | | |
| leaf bmpq-size { | | |
| type uint32; | | |
| description | | |
| "Number of elements in the write Q"; | | |
| } | | |
| leaf update-info-version { | | |
| type uint64; | | |
| description | | |
| "Update information version"; | | |
| } | | |
| leaf server-admin-down { | | |
| type boolean; | | |
| description | | |
| "Server is admin shutdown"; | | |
| } | | |
| leaf server-down { | | |
| type boolean; | | |
| description | | |
| "Server is down"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-BMP-CONVERGENCE-BAG { | | |
| description | | |
| "BGP BMP Convergence information"; | | |
| container bmp-mode { | | |
| description | | |
| "BMP mode type"; | | |
| uses BGP-BMP-CONVERGENCE-MODE; | | |
| } | | |
| leaf af-name { | | |
| type Bgp-afi; | | |
| description | | |
| "Address family identifier"; | | |
| } | | |
| leaf has-converged { | | |
| type boolean; | | |
| description | | |
| "Convergence has been reached"; | | |
| } | | |
| list bmp-per-server-information { | | |
| description | | |
| "BMP per server convergence information"; | | |
| uses BGP-BMP-CONVERGENCE-PER-SERVER; | | |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPDGEN-UPDGRP-BAG { | | grouping BGP-UPDGEN-UPDGRP-BAG { |
| description | | description |
| "BGP Update generation Update-group information"; | | "BGP Update generation Update-group information"; |
| container last-update-timer-start-timestamp { | | container last-update-timer-start-timestamp { |
| description | | description |
| n | "Start timer update for the last update"; | n | "Last update timer start time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-update-timer-stop-timestamp { | | container last-update-timer-stop-timestamp { |
| description | | description |
| n | "Timer stop time for the last update"; | n | "Last update timer stop time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-update-timer-expiry-timestamp { | | container last-update-timer-expiry-timestamp { |
| description | | description |
| n | "Timer expiry time update for last update"; | n | "Last update timer expiry time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-update-timer-remaining-value { | | container last-update-timer-remaining-value { |
| description | | description |
| "Update timer remaining time"; | | "Update timer remaining time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-update-timer-delay-value { | | container last-update-timer-delay-value { |
| description | | description |
| n | "Number of timer delayed for the last update"; | n | "Last update timer delay value"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container update-statistics { | | container update-statistics { |
| description | | description |
| n | "BGP update-group update statistics"; | n | "Update statistics"; |
| uses BGP-UPDGEN-STATS-BAG; | | uses BGP-UPDGEN-STATS-BAG; |
| } | | } |
| leaf process-id { | | leaf process-id { |
| type uint32; | | type uint32; |
| description | | description |
| "ProcessID"; | | "ProcessID"; |
| } | | } |
| leaf update-vrf-name { | | leaf update-vrf-name { |
| type string; | | type string; |
| description | | description |
| "VRF Name"; | | "VRF Name"; |
| } | | } |
| leaf update-group-af-name { | | leaf update-group-af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Address family identifier"; | | "Address family identifier"; |
| } | | } |
| leaf neighbor-session-af-name { | | leaf neighbor-session-af-name { |
| type uint8; | | type uint8; |
| description | | description |
| "Neighbor session address family"; | | "Neighbor session address family"; |
| } | | } |
| leaf update-group-index-xr { | | leaf update-group-index-xr { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Index of the BGP update group"; | n | "Update-group index"; |
| } | | } |
| leaf update-group-flags2 { | | leaf update-group-flags2 { |
| type uint32; | | type uint32; |
| description | | description |
| "Update-group internal flags2"; | | "Update-group internal flags2"; |
| } | | } |
| leaf update-out-queue-messages { | | leaf update-out-queue-messages { |
| type uint32; | | type uint32; |
| description | | description |
| "OutQueue Messages"; | | "OutQueue Messages"; |
| } | | } |
| leaf update-out-queue-size { | | leaf update-out-queue-size { |
| type uint32; | | type uint32; |
| description | | description |
| "OutQueue Size"; | | "OutQueue Size"; |
| } | | } |
| leaf update-sub-group-count { | | leaf update-sub-group-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Sub-group count"; | | "Sub-group count"; |
| } | | } |
| leaf sub-group-throttled-count { | | leaf sub-group-throttled-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Throttled sub-group count"; | | "Throttled sub-group count"; |
| } | | } |
| leaf refresh-sub-group-count { | | leaf refresh-sub-group-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of temporary refresh sub groups"; | n | "Refresh sub-group count"; |
| } | | } |
| leaf refresh-sub-group-throttled-count { | | leaf refresh-sub-group-throttled-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Throttled refresh sub-group count"; | | "Throttled refresh sub-group count"; |
| } | | } |
| leaf filter-group-count { | | leaf filter-group-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of filter groups in BGP update generation"; | n | "Filter-group count"; |
| } | | } |
| leaf neighbor-count { | | leaf neighbor-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of neighbors present in BGp update | n | "Neighbor count"; |
| generation"; | | |
| } | | } |
| leaf neighbor-leaving-count { | | leaf neighbor-leaving-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Count of neighbors leaving the update-group"; | | "Count of neighbors leaving the update-group"; |
| } | | } |
| leaf update-generation-recovery-pending { | | leaf update-generation-recovery-pending { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if update generation recovery | n | "Is update generation recovery pending"; |
| is pending"; | | |
| } | | } |
| leaf last-update-timer-expiry-age { | | leaf last-update-timer-expiry-age { |
| type uint32; | | type uint32; |
| description | | description |
| "Time since last update timer expiry event"; | | "Time since last update timer expiry event"; |
| } | | } |
| leaf is-update-timer-running { | | leaf is-update-timer-running { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if timer is running"; | n | "Is update timer running"; |
| } | | } |
| leaf perm-pelem-encountered { | | leaf perm-pelem-encountered { |
| type uint32; | | type uint32; |
| description | | description |
| "Count of Perm Pelems seen by updgen"; | | "Count of Perm Pelems seen by updgen"; |
| } | | } |
| leaf perm-pelem-allowed { | | leaf perm-pelem-allowed { |
| type uint32; | | type uint32; |
| description | | description |
| "Count of Perm Pelems allowed by updgen"; | | "Count of Perm Pelems allowed by updgen"; |
| } | | } |
| leaf perm-pelem-not-allowed { | | leaf perm-pelem-not-allowed { |
| type uint32; | | type uint32; |
| description | | description |
| "Count of Perm Pelems not allowed by updgen"; | | "Count of Perm Pelems not allowed by updgen"; |
| } | | } |
| leaf perm-pelem-exp-wdr { | | leaf perm-pelem-exp-wdr { |
| type uint32; | | type uint32; |
| description | | description |
| "Count of Perm Pelems explicitly wdrn by updgen"; | | "Count of Perm Pelems explicitly wdrn by updgen"; |
| } | | } |
| leaf perm-pelem-spur-wdr { | | leaf perm-pelem-spur-wdr { |
| type uint32; | | type uint32; |
| description | | description |
| "Count of Perm Pelems Spurious withdraws by | | "Count of Perm Pelems Spurious withdraws by |
| updgen"; | | updgen"; |
| } | | } |
| leaf is-permanent { | | leaf is-permanent { |
| type boolean; | | type boolean; |
| description | | description |
| "Permanent UG check"; | | "Permanent UG check"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-BMP-PATH-BAG { | | grouping BGP-BMP-PATH-BAG { |
| description | | description |
| "BMP Table path details"; | | "BMP Table path details"; |
| container neighbor-address { | | container neighbor-address { |
| description | | description |
| n | "BGP monitoring protocolip address of neighbor"; | n | "Neighbor Address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| n | } | n | |
| container next-hop-address { | | |
| description | | |
| "Nexthop address"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| container next-hop { | | |
| description | | |
| "BGP Next hop information"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| container attributes-after-policy-in { | | |
| description | | |
| "Attributes after inbound policy applied."; | | |
| uses BGP-ATTR; | | |
| } | | |
| container next-hop-ll-address { | | |
| description | | |
| "Nexthop link-local address"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| leaf neighbor-addpath-rx-enabled { | | |
| type boolean; | | |
| description | | |
| "Add-path receive enabled on the neighbor"; | | |
| } | | } |
| leaf bmp-path-flags { | | leaf bmp-path-flags { |
| type uint32; | | type uint32; |
| description | | description |
| "Flags associated with path"; | | "Flags associated with path"; |
| } | | } |
| leaf bmp-path-adv-bit-map { | | leaf bmp-path-adv-bit-map { |
| type uint16; | | type uint16; |
| description | | description |
| "Path's Adv bit map"; | | "Path's Adv bit map"; |
| } | | } |
| leaf bmp-path-snd-bit-map { | | leaf bmp-path-snd-bit-map { |
| type uint16; | | type uint16; |
| description | | description |
| "Path's pending snd bit map"; | | "Path's pending snd bit map"; |
| } | | } |
| leaf bmp-nbr-bit-map { | | leaf bmp-nbr-bit-map { |
| type uint32; | | type uint32; |
| description | | description |
| "Paths Nbr bmp bit map"; | | "Paths Nbr bmp bit map"; |
| } | | } |
| leaf local-path { | | leaf local-path { |
| type boolean; | | type boolean; |
| description | | description |
| "Is path originated locally?"; | | "Is path originated locally?"; |
| } | | } |
| n | leaf received-path-id { | n | |
| type uint32; | | |
| description | | |
| "Received path id"; | | |
| } | | |
| leaf local-preference { | | |
| type uint32; | | |
| description | | |
| "Local preference value"; | | |
| } | | |
| leaf bpath-pointer { | | leaf bpath-pointer { |
| type uint64; | | type uint64; |
| description | | description |
| "BGP Path pointer"; | | "BGP Path pointer"; |
| n | } | n | |
| leaf process-instance-id { | | |
| type uint8; | | |
| description | | |
| "BGP Process instance ID"; | | |
| } | | |
| leaf advertisedto-pe { | | |
| type boolean; | | |
| description | | |
| "Net could be advertised "; | | |
| } | | |
| leaf is-path-valid { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if BGP path attributes are | | |
| usable"; | | |
| } | | |
| leaf is-path-locally-sourced { | | |
| type boolean; | | |
| description | | |
| "Path sourced locally"; | | |
| } | | |
| leaf is-path-local-aggregate { | | |
| type boolean; | | |
| description | | |
| "Path is a locally created aggregate"; | | |
| } | | |
| leaf is-path-from-network-command { | | |
| type boolean; | | |
| description | | |
| "Path sourced by network command"; | | |
| } | | |
| leaf is-path-from-redistribute-command { | | |
| type boolean; | | |
| description | | |
| "Path sourced by redistribute command"; | | |
| } | | |
| leaf is-path-imported { | | |
| type boolean; | | |
| description | | |
| "Path is imported"; | | |
| } | | |
| leaf is-permanent-path { | | |
| type boolean; | | |
| description | | |
| "Path is of type Permanent path"; | | |
| } | | |
| leaf is-internal-path { | | |
| type boolean; | | |
| description | | |
| "Received over an internal link"; | | |
| } | | |
| leaf is-atomic-aggregate-present { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if Atomic aggregate attribute | | |
| present"; | | |
| } | | |
| leaf is-best-path { | | |
| type boolean; | | |
| description | | |
| "Best available path"; | | |
| } | | |
| leaf is-as-best { | | |
| type boolean; | | |
| description | | |
| "Best available path within AS"; | | |
| } | | |
| leaf is-path-multipath { | | |
| type boolean; | | |
| description | | |
| "Path is one of multipath best routes"; | | |
| } | | |
| leaf is-path-best-external { | | |
| type boolean; | | |
| description | | |
| "Path is a best external path"; | | |
| } | | |
| leaf is-path-backup { | | |
| type boolean; | | |
| description | | |
| "Path is a backup path "; | | |
| } | | |
| leaf is-path-backup-protect-multipath { | | |
| type boolean; | | |
| description | | |
| "Path is a backup path to protect multipaths"; | | |
| } | | |
| leaf is-path-imp-candidate { | | |
| type boolean; | | |
| description | | |
| "Path is a candidate for multipath import"; | | |
| } | | |
| leaf is-path-vpn-only { | | |
| type boolean; | | |
| description | | |
| "Path is not in the vrf"; | | |
| } | | |
| leaf local-nh { | | |
| type boolean; | | |
| description | | |
| "Path has local nexthop"; | | |
| } | | |
| leaf labeled-unicast-safi-path { | | |
| type boolean; | | |
| description | | |
| "Path was learnt by labeled-unicast SAFI"; | | |
| } | | |
| leaf path-flags { | | |
| type uint64; | | |
| description | | |
| "Flags associated with path"; | | |
| } | | |
| leaf path-flags2 { | | |
| type uint32; | | |
| description | | |
| "Flags2 associated with path"; | | |
| } | | |
| leaf path-import-flags { | | |
| type uint32; | | |
| description | | |
| "Flags to indicate for import processing in BGP"; | | |
| } | | |
| leaf is-path-from-confederation-peer { | | |
| type boolean; | | |
| description | | |
| "Path received from confederation peer"; | | |
| } | | |
| leaf local-path-id { | | |
| type uint32; | | |
| description | | |
| "Local path ID"; | | |
| } | | |
| leaf path-table-version { | | |
| type uint64; | | |
| description | | |
| "Table version # for pelem"; | | |
| } | | |
| leaf neighbor-router-id { | | |
| type inet:ipv4-address; | | |
| description | | |
| "Router ID of the neighbor for the path"; | | |
| } | | |
| leaf nexthop-interface-handle { | | |
| type uint32; | | |
| description | | |
| "Interface Handle of Nexthop"; | | |
| } | | |
| leaf accept-own-path { | | |
| type boolean; | | |
| description | | |
| "Accept Own"; | | |
| } | | |
| leaf accept-own-self-originated-path { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if BGP path is Accept-Own | | |
| community and self-originated"; | | |
| } | | |
| leaf is-path-not-advertised { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if path is not advertised to | | |
| any peer"; | | |
| } | | |
| leaf is-path-not-advertised-to-ebgp { | | |
| type boolean; | | |
| description | | |
| "Not advertised to EBGPs"; | | |
| } | | |
| leaf is-path-advertised-local-as-only { | | |
| type boolean; | | |
| description | | |
| "Not advertised outside local AS"; | | |
| } | | |
| leaf next-hop-route-distinguisher-valid { | | |
| type boolean; | | |
| description | | |
| "Route Distinguisher of the nexthop is valid"; | | |
| } | | |
| leaf next-hop-route-distinguisher { | | |
| type xr:Route-dist; | | |
| description | | |
| "Route Distinguisher of the nexthop"; | | |
| } | | |
| leaf next-hop-ll-route-distinguisher-valid { | | |
| type boolean; | | |
| description | | |
| "Route Distinguisher of the link-local nexthop is | | |
| valid"; | | |
| } | | |
| leaf next-hop-ll-route-distinguisher { | | |
| type xr:Route-dist; | | |
| description | | |
| "Route Distinguisher of the link-local nexthop"; | | |
| } | | } |
| list received-label { | | list received-label { |
| description | | description |
| "Set of received label stack"; | | "Set of received label stack"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Set of received label stack"; | | "Set of received label stack"; |
| } | | } |
| } | | } |
| n | list local-peers-advertised-to { | n | |
| description | | |
| "Local peers that this prefix has been advertised | | |
| to"; | | |
| uses BGP-ADVINFO-TYPE; | | |
| } | | |
| list pe-peers-advertised-to { | | |
| description | | |
| "PE peers that this prefix has been advertised to"; | | |
| uses BGP-ADVINFO-TYPE; | | |
| } | | |
| list best-path-orrbitfield { | | |
| description | | |
| "ORR Best path Bitfields"; | | |
| uses BGP-ADVINFO-TYPE; | | |
| } | | |
| list add-path-orrbitfield { | | |
| description | | |
| "ORR Add path Bitfields"; | | |
| uses BGP-ADVINFO-TYPE; | | |
| } | | |
| } | | } |
| | | |
| grouping BGP-BMP-NET-BAG { | | grouping BGP-BMP-NET-BAG { |
| description | | description |
| "BMP Table net details"; | | "BMP Table net details"; |
| container bgp-prefix { | | container bgp-prefix { |
| description | | description |
| "BGP prefix"; | | "BGP prefix"; |
| uses BGP-PREFIXTYPE; | | uses BGP-PREFIXTYPE; |
| } | | } |
| container version-timestamp { | | container version-timestamp { |
| description | | description |
| "Net Version bump timestamp"; | | "Net Version bump timestamp"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container version-age { | | container version-age { |
| description | | description |
| "Net Version bump age"; | | "Net Version bump age"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| leaf af-name { | | leaf af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Address family identifier"; | | "Address family identifier"; |
| } | | } |
| n | leaf route-distinguisher { | n | |
| type xr:Route-dist; | | |
| description | | |
| "Route Distinguisher"; | | |
| } | | |
| leaf rd-version { | | |
| type uint64; | | |
| description | | |
| "Route Distinguisher Version"; | | |
| } | | |
| leaf vrf-name { | | |
| type string; | | |
| description | | |
| "Name of the VRF"; | | |
| } | | |
| leaf bmp-net-flags { | | leaf bmp-net-flags { |
| type uint32; | | type uint32; |
| description | | description |
| "Flags associated with net"; | | "Flags associated with net"; |
| } | | } |
| n | leaf net-extended-flags { | n | |
| type uint32; | | |
| description | | |
| "BGP network flags for extended"; | | |
| } | | |
| leaf bmp-net-version { | | leaf bmp-net-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Net's version"; | | "Net's version"; |
| } | | } |
| leaf num-of-path { | | leaf num-of-path { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of path for the net"; | | "Number of path for the net"; |
| } | | } |
| leaf has-local-label { | | leaf has-local-label { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if local label is present in | n | "Net has local label"; |
| netbag"; | | |
| } | | } |
| leaf net-local-label { | | leaf net-local-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Local label"; | | "Local label"; |
| n | } | n | |
| leaf bmp-mode { | | |
| type uint8; | | |
| description | | |
| "BMP Route Monitoring Mode"; | | |
| } | | } |
| list bmp-path { | | list bmp-path { |
| description | | description |
| "List of paths under the BMP net"; | | "List of paths under the BMP net"; |
| uses BGP-BMP-PATH-BAG; | | uses BGP-BMP-PATH-BAG; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-RTSET { | | grouping BGP-RTSET { |
| description | | description |
| "BGP RT-set"; | | "BGP RT-set"; |
| leaf rt-set-len { | | leaf rt-set-len { |
| type uint8; | | type uint8; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Length in bytes of set of route targets"; | | "Length in bytes of set of route targets"; |
| } | | } |
| leaf rt-set-id { | | leaf rt-set-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Identifier of the rtset"; | | "Identifier of the rtset"; |
| } | | } |
| leaf rt-set-net-count { | | leaf rt-set-net-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Count of nets with paths with the rtset"; | | "Count of nets with paths with the rtset"; |
| } | | } |
| list rt-set { | | list rt-set { |
| description | | description |
| "Set of route targets"; | | "Set of route targets"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "Set of route targets"; | | "Set of route targets"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping BGP-RTSET-BAG { | | grouping BGP-RTSET-BAG { |
| description | | description |
| "BGP RT-set information"; | | "BGP RT-set information"; |
| container route-target-set { | | container route-target-set { |
| description | | description |
| n | "BGP route target set"; | n | "Route Target set"; |
| uses BGP-RTSET; | | uses BGP-RTSET; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-INT-NH-GW { | | grouping BGP-INT-NH-GW { |
| description | | description |
| "BGP Internal Nexthop Gateway Information"; | | "BGP Internal Nexthop Gateway Information"; |
| leaf gateway-flags { | | leaf gateway-flags { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Flags in BGP gateway next hop"; | n | "Gateway flags"; |
| } | | } |
| leaf registration-type { | | leaf registration-type { |
| type Bgp-nh-validate; | | type Bgp-nh-validate; |
| description | | description |
| n | "Registration type for next hop"; | n | "Nexthop registration type"; |
| } | | } |
| leaf registration-since { | | leaf registration-since { |
| type uint32; | | type uint32; |
| description | | description |
| "Time since registration"; | | "Time since registration"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-INT-NH { | | grouping BGP-INT-NH { |
| description | | description |
| "BGP Internal Nexthop information"; | | "BGP Internal Nexthop information"; |
| container nexthop-address { | | container nexthop-address { |
| description | | description |
| n | "IP address of the next hop in BGP"; | n | "Nexthop address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| leaf nexthop-id { | | leaf nexthop-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Comm librray ID"; | | "Comm librray ID"; |
| } | | } |
| leaf nexthop-version { | | leaf nexthop-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Table version"; | | "Table version"; |
| } | | } |
| leaf nexthop-flags { | | leaf nexthop-flags { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Flags associated with the next hop address in | n | "Nexthop flags"; |
| BGP"; | | |
| } | | } |
| leaf nexthop-if-handle { | | leaf nexthop-if-handle { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Interface handle associated with the next hop | n | "Nexthop ifhandle"; |
| address in BGP"; | | |
| } | | } |
| leaf nexthop-af-user-bits { | | leaf nexthop-af-user-bits { |
| type uint32; | | type uint32; |
| description | | description |
| "Bitmask indicating the AFs which share the | | "Bitmask indicating the AFs which share the |
| nexthop"; | | nexthop"; |
| } | | } |
| leaf nexthop-label { | | leaf nexthop-label { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Label associated with the next hop address"; | n | "Nexthop label"; |
| } | | } |
| leaf gateway-flags { | | leaf gateway-flags { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP nexthop gateway flags"; | n | "Gateway flags"; |
| } | | } |
| list nexthop-metrice { | | list nexthop-metrice { |
| description | | description |
| n | "Metrices associated with the next hop address in | n | "Nexthop metrices"; |
| | | |
| BGP"; | | |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Metrices associated with the next hop address in | n | "Nexthop metrices"; |
| | | |
| BGP"; | | |
| } | | } |
| } | | } |
| list nexthop-refcount { | | list nexthop-refcount { |
| description | | description |
| n | "reference counts for the next hop"; | n | "Nexthop refcounts"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| n | "reference counts for the next hop"; | n | "Nexthop refcounts"; |
| } | | |
| } | | |
| list nexthop-encap-type { | | |
| description | | |
| "Encap types associated with the next hop address | | |
| | | |
| in BGP"; | | |
| leaf entry { | | |
| type uint16; | | |
| description | | |
| "Encap types associated with the next hop address | | |
| | | |
| in BGP"; | | |
| } | | } |
| } | | } |
| list nexthop-gateway-internal-info { | | list nexthop-gateway-internal-info { |
| description | | description |
| "Internal nexthop Gateway info"; | | "Internal nexthop Gateway info"; |
| uses BGP-INT-NH-GW; | | uses BGP-INT-NH-GW; |
| } | | } |
| } | | } |
| | | |
| n | grouping BGP-NH-METRIC-EVENT { | n | |
| description | | |
| "BGP nexthop metric change event"; | | |
| leaf event-time { | | |
| type uint64; | | |
| description | | |
| "Time at which the nexthop metric change occurred | | |
| in nsec since epoch"; | | |
| } | | |
| leaf nexthop-metric { | | |
| type uint32; | | |
| description | | |
| "IGP metric for nexthop. Max uint32 value (4,294 | | |
| ,967,295) indicates the nexthop is unreachable"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-NEXTHOP-GW-INFO { | | grouping BGP-NEXTHOP-GW-INFO { |
| description | | description |
| "BGP Nexthop GW info"; | | "BGP Nexthop GW info"; |
| container nexthop-route { | | container nexthop-route { |
| description | | description |
| n | "Route resolving the nexthop"; | n | "Route resolving the nethop"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| leaf nexthop-route-prefix-length { | | leaf nexthop-route-prefix-length { |
| type uint8; | | type uint8; |
| description | | description |
| "Prefix length of the route resolving the nexthop"; | | "Prefix length of the route resolving the nexthop"; |
| } | | } |
| leaf nexthop-route-protocol { | | leaf nexthop-route-protocol { |
| type string; | | type string; |
| description | | description |
| "Protocol that resolves the route to the nexthop"; | | "Protocol that resolves the route to the nexthop"; |
| } | | } |
| leaf nexthop-route-path-count { | | leaf nexthop-route-path-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Count of paths in the resolving route"; | n | "Number of paths in the resolving route"; |
| } | | } |
| leaf nexthop-af-invalid-bits { | | leaf nexthop-af-invalid-bits { |
| type uint16; | | type uint16; |
| description | | description |
| n | "Bitmask indicating the address-family which have | n | "Bitmask indicating the AFs which have been |
| been invalidated for the nexthop"; | | invalidated for the nexthop"; |
| } | | } |
| leaf nexthop-status { | | leaf nexthop-status { |
| type uint8; | | type uint8; |
| description | | description |
| n | "Status of the next hop address"; | n | "Nexthop status"; |
| } | | } |
| leaf nexthop-tableid { | | leaf nexthop-tableid { |
| type uint64; | | type uint64; |
| description | | description |
| n | "BGP gateway neighbor route table id"; | n | "Nexthop Table id"; |
| } | | } |
| leaf nexthop-metric { | | leaf nexthop-metric { |
| type uint32; | | type uint32; |
| description | | description |
| "IGP metric for nexthop"; | | "IGP metric for nexthop"; |
| n | } | n | |
| leaf orrafi-used-bits { | | |
| type uint32; | | |
| description | | |
| "ORR afi bits"; | | |
| } | | } |
| leaf last-event-type { | | leaf last-event-type { |
| type Bgp-nh-event; | | type Bgp-nh-event; |
| description | | description |
| "Last nexthop event type"; | | "Last nexthop event type"; |
| } | | } |
| leaf last-update-type { | | leaf last-update-type { |
| type Bgp-nh-update; | | type Bgp-nh-update; |
| description | | description |
| "Last nexthop update type"; | | "Last nexthop update type"; |
| } | | } |
| leaf critical-events { | | leaf critical-events { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Count of critical events received from RIB"; | n | "Number of critical events received from RIB"; |
| } | | } |
| leaf non-critical-events { | | leaf non-critical-events { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Count of non-critical events received from RIB"; | n | "Number of non-critical events received from RIB"; |
| } | | } |
| leaf last-event-since { | | leaf last-event-since { |
| type uint32; | | type uint32; |
| description | | description |
| "Time since the last event sent to or received | | "Time since the last event sent to or received |
| from RIB"; | | from RIB"; |
| } | | } |
| leaf last-rib-update { | | leaf last-rib-update { |
| type uint32; | | type uint32; |
| description | | description |
| "Time since the last rib update happened"; | | "Time since the last rib update happened"; |
| } | | } |
| leaf nexthop-mpls-enabled { | | leaf nexthop-mpls-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if MPLS is configured for IAS/CsC | | "TRUE if MPLS is configured for IAS/CsC |
| application"; | | application"; |
| } | | } |
| leaf nexthop-mpls-interfaces { | | leaf nexthop-mpls-interfaces { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Count of interfaces on which MPLS is enabled"; | n | "Number of interfaces on which MPLS is enabled"; |
| } | | } |
| leaf nexthop-mpls-label { | | leaf nexthop-mpls-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Local label allocated for IAS/CsC application"; | | "Local label allocated for IAS/CsC application"; |
| } | | } |
| n | leaf unreachable-count { | n | |
| type uint16; | | |
| description | | |
| "Number of times the nexthop became unreachable"; | | |
| } | | |
| leaf reachable-count { | | |
| type uint16; | | |
| description | | |
| "Number of times the nexthop became reachable"; | | |
| } | | |
| leaf metric-increase-count { | | |
| type uint16; | | |
| description | | |
| "Number of times metric increased for this | | |
| nexthop"; | | |
| } | | |
| leaf metric-decrease-count { | | |
| type uint16; | | |
| description | | |
| "Number of times metric decreased for this | | |
| nexthop"; | | |
| } | | |
| leaf last-reachable { | | |
| type uint64; | | |
| description | | |
| "Time at which this nexthop was last reachable in | | |
| nsec since epoch"; | | |
| } | | |
| leaf last-unreachable { | | |
| type uint64; | | |
| description | | |
| "Time at which this nexthop was last unreachable | | |
| in nsec since epoch"; | | |
| } | | |
| list nexthop-route-path { | | list nexthop-route-path { |
| description | | description |
| n | "Nexthop paths of the resolving route"; | n | "Nexthops of the resolving route"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| n | } | n | |
| list events { | | |
| description | | |
| "History of metric and reachablity changes"; | | |
| uses BGP-NH-METRIC-EVENT; | | |
| } | | } |
| } | | } |
| | | |
| grouping BGP-NEXTHOP-BAG { | | grouping BGP-NEXTHOP-BAG { |
| description | | description |
| "BGP Nexthop info"; | | "BGP Nexthop info"; |
| container nexthop-address { | | container nexthop-address { |
| description | | description |
| n | "IP address of nexthop in BGP"; | n | "Nexthop address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container nh-tunnel { | | container nh-tunnel { |
| description | | description |
| "NH tunnel information"; | | "NH tunnel information"; |
| uses BGP-TE-TUNNEL; | | uses BGP-TE-TUNNEL; |
| } | | } |
| container nexthop-internal-info { | | container nexthop-internal-info { |
| description | | description |
| "Internal nexthop info"; | | "Internal nexthop info"; |
| uses BGP-INT-NH; | | uses BGP-INT-NH; |
| } | | } |
| leaf af-name { | | leaf af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Address family identifier"; | | "Address family identifier"; |
| } | | } |
| leaf rib-nexthop-id { | | leaf rib-nexthop-id { |
| type uint32; | | type uint32; |
| description | | description |
| "RIB Nexthop Id"; | | "RIB Nexthop Id"; |
| } | | } |
| leaf nexthop-pending-registration { | | leaf nexthop-pending-registration { |
| type uint8; | | type uint8; |
| description | | description |
| "Nexthop registration is pending"; | | "Nexthop registration is pending"; |
| } | | } |
| leaf nexthop-reference-count { | | leaf nexthop-reference-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Count of neighbors/prefixes referencing this | n | "Number of neighbors/prefixes referencing this |
| nexthop"; | | nexthop"; |
| } | | } |
| leaf nh-reference-count-total { | | leaf nh-reference-count-total { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Count of neighbors/prefixes referencing this | n | "Number of neighbors/prefixes referencing this |
| nexthop (AFs)"; | | nexthop (AFs)"; |
| } | | } |
| leaf nh-first-hop-if-handle { | | leaf nh-first-hop-if-handle { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "First-hop interface handle"; | | "First-hop interface handle"; |
| } | | } |
| leaf nexthop-aigp-metric { | | leaf nexthop-aigp-metric { |
| type uint32; | | type uint32; |
| description | | description |
| "AIGP metrice of nexthop"; | | "AIGP metrice of nexthop"; |
| } | | } |
| leaf nexthop-gateway-reachable { | | leaf nexthop-gateway-reachable { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if Gateway is reachable"; | n | "Is Gateway reachable ?"; |
| } | | } |
| leaf nexthop-gateway-prefix-connected { | | leaf nexthop-gateway-prefix-connected { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if Gateway resolved through | n | "Is Gateway resolved through Connected route ?"; |
| Connected route"; | | |
| } | | } |
| leaf nexthop-gateway-prefix-length { | | leaf nexthop-gateway-prefix-length { |
| type uint32; | | type uint32; |
| description | | description |
| "Gateway prefix length"; | | "Gateway prefix length"; |
| } | | } |
| n | leaf nexthop-hash-slot { | n | |
| type uint32; | | |
| description | | |
| "Sync Hash slot of Nexthop"; | | |
| } | | |
| list nexthop-gateway-info { | | list nexthop-gateway-info { |
| description | | description |
| n | "Gateway related info, including Optimal Route | n | "Gateway related info, includingOptimal Route |
| Reflector Gateways"; | | Reflector Gateways"; |
| uses BGP-NEXTHOP-GW-INFO; | | uses BGP-NEXTHOP-GW-INFO; |
| } | | } |
| list neighbor-address { | | list neighbor-address { |
| description | | description |
| "Neighbor Address List"; | | "Neighbor Address List"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| } | | } |
| | | |
| n | grouping BGP-NH-PERF-CTRS { | n | |
| description | | |
| "BGP nexthop counters for a VRF AF"; | | |
| leaf reachable-count { | | |
| type uint64; | | |
| description | | |
| "Number of times the nexthop became reachable in | | |
| this interval"; | | |
| } | | |
| leaf unreachable-count { | | |
| type uint64; | | |
| description | | |
| "Number of times the nexthop became unreachable | | |
| in this interval"; | | |
| } | | |
| leaf metric-increase-count { | | |
| type uint64; | | |
| description | | |
| "Number of times metric increased for this | | |
| nexthop in this interval"; | | |
| } | | |
| leaf metric-decrease-count { | | |
| type uint64; | | |
| description | | |
| "Number of times metric decreased for this | | |
| nexthop in this interval"; | | |
| } | | |
| leaf start-time { | | |
| type uint64; | | |
| description | | |
| "Start time of the interval in nsec since epoch"; | | |
| } | | |
| leaf end-time { | | |
| type uint64; | | |
| description | | |
| "End time of the interval in nsec since epoch"; | | |
| } | | |
| leaf time-duration { | | |
| type uint16; | | |
| units "minute"; | | |
| description | | |
| "Duration of the interval in minutes"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-NEXTHOP-PERF-VRF-AF-BAG { | | grouping BGP-NEXTHOP-PERF-VRF-AF-BAG { |
| description | | description |
| "BGP nexthop statistics for a VRF AF"; | | "BGP nexthop statistics for a VRF AF"; |
| n | container live-counters { | n | |
| description | | |
| "BGP next hop VRF live counters"; | | |
| uses BGP-NH-PERF-CTRS; | | |
| } | | |
| leaf critical-notf-count { | | leaf critical-notf-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of critical event notifications from RIB"; | | "Number of critical event notifications from RIB"; |
| } | | } |
| leaf noncritical-notf-count { | | leaf noncritical-notf-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of non-critical event notifications from | | "Number of non-critical event notifications from |
| RIB"; | | RIB"; |
| } | | } |
| leaf last-notf-bestpath-deletes { | | leaf last-notf-bestpath-deletes { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of bestpath deletes due to last | | "Number of bestpath deletes due to last |
| notification"; | | notification"; |
| } | | } |
| leaf last-notf-bestpath-changes { | | leaf last-notf-bestpath-changes { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of bestpath changes due to last | | "Number of bestpath changes due to last |
| notification"; | | notification"; |
| } | | } |
| leaf nh-sync-reg-calls { | | leaf nh-sync-reg-calls { |
| type uint32; | | type uint32; |
| description | | description |
| "NH sync register calls"; | | "NH sync register calls"; |
| } | | } |
| leaf nha-sync-reg-calls { | | leaf nha-sync-reg-calls { |
| type uint32; | | type uint32; |
| description | | description |
| "NH async register calls"; | | "NH async register calls"; |
| } | | } |
| leaf nha-sync-un-reg-calls { | | leaf nha-sync-un-reg-calls { |
| type uint32; | | type uint32; |
| description | | description |
| "NH async unregister calls"; | | "NH async unregister calls"; |
| } | | } |
| leaf nh-pending-registrations { | | leaf nh-pending-registrations { |
| type uint32; | | type uint32; |
| description | | description |
| "NH Registration List Count"; | | "NH Registration List Count"; |
| } | | } |
| leaf nh-peak-registrations { | | leaf nh-peak-registrations { |
| type uint32; | | type uint32; |
| description | | description |
| "NH Registration List Count Peak"; | | "NH Registration List Count Peak"; |
| } | | } |
| leaf nh-batch-finish-calls { | | leaf nh-batch-finish-calls { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Count of the batch finish calls for next hop"; | n | "NH batch finish calls"; |
| } | | } |
| leaf nh-flush-timer-calls { | | leaf nh-flush-timer-calls { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Count of the flush timer calls for net hop"; | n | "NH flush timer calls"; |
| } | | } |
| leaf nh-last-sync-reg-ts { | | leaf nh-last-sync-reg-ts { |
| type uint32; | | type uint32; |
| description | | description |
| "NH Last sync Register TS"; | | "NH Last sync Register TS"; |
| } | | } |
| leaf nh-last-a-sync-reg-ts { | | leaf nh-last-a-sync-reg-ts { |
| type uint32; | | type uint32; |
| description | | description |
| "NH Last async Register TS"; | | "NH Last async Register TS"; |
| } | | } |
| leaf nh-last-a-sync-un-reg-ts { | | leaf nh-last-a-sync-un-reg-ts { |
| type uint32; | | type uint32; |
| description | | description |
| "NH Last async UnRegister TS"; | | "NH Last async UnRegister TS"; |
| } | | } |
| leaf nh-last-batch-finish-ts { | | leaf nh-last-batch-finish-ts { |
| type uint32; | | type uint32; |
| description | | description |
| "NH Last batch finish TS"; | | "NH Last batch finish TS"; |
| } | | } |
| leaf nh-last-flush-timer-ts { | | leaf nh-last-flush-timer-ts { |
| type uint32; | | type uint32; |
| description | | description |
| "NH Last flush timer TS"; | | "NH Last flush timer TS"; |
| } | | } |
| leaf nhrib-update-calls { | | leaf nhrib-update-calls { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of calls to RIB update function"; | | "No. of calls to RIB update function"; |
| } | | } |
| leaf nhrib-update-time { | | leaf nhrib-update-time { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Time spent sending RIB updates (milliseconds)"; | | "Time spent sending RIB updates (milliseconds)"; |
| } | | } |
| leaf nexthops-sent-to-rib { | | leaf nexthops-sent-to-rib { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of nexthops sent to RIB"; | | "No. of nexthops sent to RIB"; |
| } | | } |
| leaf nexthops-resent-to-rib { | | leaf nexthops-resent-to-rib { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of nexthops re-sent to RIB"; | | "No. of nexthops re-sent to RIB"; |
| } | | } |
| leaf nexthops-removed-from-rib { | | leaf nexthops-removed-from-rib { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of nexthops withdrawn from RIB"; | | "No. of nexthops withdrawn from RIB"; |
| } | | } |
| leaf rib-sync-registers-failed { | | leaf rib-sync-registers-failed { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of sync registers with RIB that failed"; | | "No. of sync registers with RIB that failed"; |
| } | | } |
| leaf riba-sync-registers-failed { | | leaf riba-sync-registers-failed { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of async registers with RIB that failed"; | | "No. of async registers with RIB that failed"; |
| } | | } |
| leaf ribnh-reg-failed-for-no-tbl-id { | | leaf ribnh-reg-failed-for-no-tbl-id { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of nh registers failed because of no tbl-id"; | | "No. of nh registers failed because of no tbl-id"; |
| } | | } |
| leaf ribnh-reg-failed-for-no-rib-conn { | | leaf ribnh-reg-failed-for-no-rib-conn { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of nh registers failed because of no rib | | "No. of nh registers failed because of no rib |
| conn"; | | conn"; |
| } | | } |
| leaf tunnel-walk-nh-not-found { | | leaf tunnel-walk-nh-not-found { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of times nexthop was not found during tunnel | | "No. of times nexthop was not found during tunnel |
| walk"; | | walk"; |
| } | | } |
| leaf tunnel-walk-gw-not-found { | | leaf tunnel-walk-gw-not-found { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of times gw was not found during tunnel walk"; | | "No. of times gw was not found during tunnel walk"; |
| } | | } |
| leaf tunnel-walk-backup-creates { | | leaf tunnel-walk-backup-creates { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of times backup tid created during tunnel | | "No. of times backup tid created during tunnel |
| walk"; | | walk"; |
| } | | } |
| n | leaf total-unreachable-count { | n | |
| type uint64; | | |
| description | | |
| "Number of times any nexthop became unreachable | | |
| in GW AFI"; | | |
| } | | |
| leaf total-reachable-count { | | |
| type uint64; | | |
| description | | |
| "Number of times any nexthop became reachable in | | |
| GW AFI"; | | |
| } | | |
| leaf total-metric-increase-count { | | |
| type uint64; | | |
| description | | |
| "Number of times metric increased for any nexthop | | |
| in GW AFI"; | | |
| } | | |
| leaf total-metric-decrease-count { | | |
| type uint64; | | |
| description | | |
| "Number of times metric decreased for any nexthop | | |
| in GW AFI"; | | |
| } | | |
| list counters { | | |
| description | | |
| "List of BGP next hop VRF counters"; | | |
| uses BGP-NH-PERF-CTRS; | | |
| } | | |
| } | | } |
| | | |
| grouping BGP-NEXTHOP-VRF-AF-BAG { | | grouping BGP-NEXTHOP-VRF-AF-BAG { |
| description | | description |
| "BGP nexthop processing information for a VRF AF"; | | "BGP nexthop processing information for a VRF AF"; |
| container performance-statistics { | | container performance-statistics { |
| description | | description |
| n | "BGP next hop virtual routingand forwarding | n | |
| performancestatistics"; | | "Performance statistics"; |
| uses BGP-NEXTHOP-PERF-VRF-AF-BAG; | | uses BGP-NEXTHOP-PERF-VRF-AF-BAG; |
| } | | } |
| leaf af-name { | | leaf af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Address family identifier"; | | "Address family identifier"; |
| } | | } |
| leaf gwaf-name { | | leaf gwaf-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "GW Address family identifier"; | | "GW Address family identifier"; |
| } | | } |
| leaf total-nexthops { | | leaf total-nexthops { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of nexthops"; | | "Total number of nexthops"; |
| } | | } |
| leaf critical-trigger-delay { | | leaf critical-trigger-delay { |
| type uint32; | | type uint32; |
| description | | description |
| "Trigger delay for critical event processing"; | | "Trigger delay for critical event processing"; |
| } | | } |
| leaf non-critical-trigger-delay { | | leaf non-critical-trigger-delay { |
| type uint32; | | type uint32; |
| description | | description |
| "Trigger delay for non-critical event processing"; | | "Trigger delay for non-critical event processing"; |
| } | | } |
| leaf table-active { | | leaf table-active { |
| type boolean; | | type boolean; |
| description | | description |
| "Whether the VRF is active"; | | "Whether the VRF is active"; |
| } | | } |
| leaf nh-rib-up { | | leaf nh-rib-up { |
| type boolean; | | type boolean; |
| description | | description |
| "Whether the VRF is active"; | | "Whether the VRF is active"; |
| } | | } |
| leaf nh-rib-version { | | leaf nh-rib-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "RIB version for gw_ctx"; | | "RIB version for gw_ctx"; |
| } | | } |
| leaf nh-nexthop-version { | | leaf nh-nexthop-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "NH version for gw_ctx"; | | "NH version for gw_ctx"; |
| } | | } |
| leaf nh-table-id { | | leaf nh-table-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Gateway context table id"; | | "Gateway context table id"; |
| } | | } |
| leaf epe-table-version { | | leaf epe-table-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Version of the EPE table"; | | "Version of the EPE table"; |
| } | | } |
| leaf epe-label-version { | | leaf epe-label-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Version of the EPE label walk"; | | "Version of the EPE label walk"; |
| } | | } |
| leaf epe-downloaded-version { | | leaf epe-downloaded-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Version of the EPE table downloaded"; | | "Version of the EPE table downloaded"; |
| } | | } |
| leaf epe-standby-version { | | leaf epe-standby-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Version of the EPE table processed by sync | | "Version of the EPE table processed by sync |
| thread"; | | thread"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPDGEN-SUBGRP-BAG { | | grouping BGP-UPDGEN-SUBGRP-BAG { |
| description | | description |
| "BGP Update generation Sub-group information"; | | "BGP Update generation Sub-group information"; |
| container creation-timestamp { | | container creation-timestamp { |
| description | | description |
| "Creation time"; | | "Creation time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-merge-timestamp { | | container last-merge-timestamp { |
| description | | description |
| "Last merge time"; | | "Last merge time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container first-update-walk-start-timestamp { | | container first-update-walk-start-timestamp { |
| description | | description |
| n | "BGP update generation sub-group start time for | n | "First update walk start time"; |
| the first update walk"; | | |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container first-update-walk-end-timestamp { | | container first-update-walk-end-timestamp { |
| description | | description |
| n | "BGP update generation sub-group end time for | n | |
| thefirst update walk"; | | "First update walk end time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-update-walk-start-timestamp { | | container last-update-walk-start-timestamp { |
| description | | description |
| n | "BGP update generation sub-group start for | n | "Last update walk start time"; |
| thelast update"; | | |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-update-walk-end-timestamp { | | container last-update-walk-end-timestamp { |
| description | | description |
| n | "BGP update generation sub-group end time for | n | "Last update walk end time"; |
| thelast update"; | | |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-update-queued-timestamp { | | container last-update-queued-timestamp { |
| description | | description |
| n | "Time when last update queued event"; | n | "Last update queued time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container update-statistics { | | container update-statistics { |
| description | | description |
| n | "BGP subgroup statistics update"; | n | "Update statistics"; |
| uses BGP-UPDGEN-STATS-BAG; | | uses BGP-UPDGEN-STATS-BAG; |
| } | | } |
| leaf process-id { | | leaf process-id { |
| type uint32; | | type uint32; |
| description | | description |
| "ProcessID"; | | "ProcessID"; |
| } | | } |
| leaf update-vrf-name { | | leaf update-vrf-name { |
| type string; | | type string; |
| description | | description |
| "VRF Name"; | | "VRF Name"; |
| } | | } |
| leaf update-group-af-name { | | leaf update-group-af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Address family identifier"; | | "Address family identifier"; |
| } | | } |
| leaf sub-group-index-xr { | | leaf sub-group-index-xr { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Index for BGP sub-group"; | n | "Sub-group index"; |
| } | | } |
| leaf sub-group-id-xr { | | leaf sub-group-id-xr { |
| type uint32; | | type uint32; |
| description | | description |
| "Sub-group ID"; | | "Sub-group ID"; |
| } | | } |
| leaf parent-sub-group-index { | | leaf parent-sub-group-index { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Index of the parent sub-group"; | n | "Parent Sub-group index"; |
| } | | } |
| leaf parent-sub-group-id { | | leaf parent-sub-group-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Parent Sub-group identifier"; | | "Parent Sub-group identifier"; |
| } | | } |
| leaf update-group-index-xr { | | leaf update-group-index-xr { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Index of the this BGp update group"; | n | "Update-group index"; |
| } | | } |
| leaf update-main-table-version { | | leaf update-main-table-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Main table version"; | | "Main table version"; |
| } | | } |
| leaf update-vrf-table-rib-version { | | leaf update-vrf-table-rib-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "VRF Table RIB version"; | | "VRF Table RIB version"; |
| } | | } |
| leaf current-update-limit-sub-group { | | leaf current-update-limit-sub-group { |
| type uint32; | | type uint32; |
| description | | description |
| "Current update limit"; | | "Current update limit"; |
| } | | } |
| leaf configured-update-limit-sub-group { | | leaf configured-update-limit-sub-group { |
| type uint32; | | type uint32; |
| description | | description |
| "Configured update limit"; | | "Configured update limit"; |
| } | | } |
| leaf update-out-queue-messages { | | leaf update-out-queue-messages { |
| type uint32; | | type uint32; |
| description | | description |
| "OutQueue messages"; | | "OutQueue messages"; |
| } | | } |
| leaf update-out-queue-size { | | leaf update-out-queue-size { |
| type uint32; | | type uint32; |
| description | | description |
| "OutQueue size"; | | "OutQueue size"; |
| } | | } |
| leaf update-throttled { | | leaf update-throttled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to verify update throttled in BGPupdate | n | "Is update throttled"; |
| generation sub-group"; | | |
| } | | } |
| leaf refresh-sub-group-count { | | leaf refresh-sub-group-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of times BGP Update generation | n | "Refresh sub-group count"; |
| sub-grouprefreshed"; | | |
| } | | } |
| leaf filter-group-count { | | leaf filter-group-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of filter groups are present in BGPupdate | n | "Filter-group count"; |
| generation"; | | |
| } | | } |
| leaf neighbor-count { | | leaf neighbor-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of neighbors in the sub-group"; | n | "Neighbor count"; |
| } | | } |
| leaf version { | | leaf version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| n | "Version up to which we have generated updatesfor | n | "Version"; |
| the entity"; | | |
| } | | } |
| leaf nsr-version { | | leaf nsr-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "NSR version"; | | "NSR version"; |
| } | | } |
| leaf pending-target-version { | | leaf pending-target-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| n | "Target version for pending update generation"; | n | "Pending target version"; |
| } | | } |
| leaf next-resume-version { | | leaf next-resume-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| n | "Version number identifying the next net | n | "Next resume version"; |
| toprocess when an attribute table walk has been | | |
| interrupted"; | | |
| } | | } |
| leaf update-refresh-target-version { | | leaf update-refresh-target-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| n | "Target version for update generation in response | n | "Refresh target version"; |
| to arefresh request"; | | |
| } | | } |
| leaf io-write-event-pending { | | leaf io-write-event-pending { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag for an event has been sent to the IO thread"; | n | "Is IO write event pending"; |
| } | | } |
| leaf merge-count { | | leaf merge-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of times BGP update sub-groups have been | n | "Merge count"; |
| merged"; | | |
| } | | } |
| leaf last-merged-sub-group-index { | | leaf last-merged-sub-group-index { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP subgroup index merge happened last time"; | n | "Last merged sub-group index"; |
| } | | } |
| leaf eo-r-attempted { | | leaf eo-r-attempted { |
| type boolean; | | type boolean; |
| description | | description |
| "Sending EoR has been attempted"; | | "Sending EoR has been attempted"; |
| } | | } |
| leaf last-update-walk-end-age { | | leaf last-update-walk-end-age { |
| type uint32; | | type uint32; |
| description | | description |
| "Time since last update walk end event"; | | "Time since last update walk end event"; |
| } | | } |
| leaf last-update-queued-age { | | leaf last-update-queued-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last update queued event (in seconds)"; | | "Time since last update queued event (in seconds)"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-ATTR-BAG { | | grouping BGP-ATTR-BAG { |
| description | | description |
| "BGP attribute information"; | | "BGP attribute information"; |
| container attribute-info { | | container attribute-info { |
| description | | description |
| "Attributes"; | | "Attributes"; |
| uses BGP-ATTR; | | uses BGP-ATTR; |
| } | | } |
| leaf process-instance-id { | | leaf process-instance-id { |
| type uint8; | | type uint8; |
| description | | description |
| n | "BGP attribute process instance ID"; | n | "Process instance ID"; |
| } | | } |
| leaf attribute-instance-id { | | leaf attribute-instance-id { |
| type uint8; | | type uint8; |
| description | | description |
| n | "Instance ID for BGP attribute context "; | n | "Attribute Instance ID"; |
| } | | } |
| leaf attribute-structure-id { | | leaf attribute-structure-id { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP ID of attribute structure information"; | n | "ID of attribute structure"; |
| } | | } |
| leaf attribute-structure-hash-value { | | leaf attribute-structure-hash-value { |
| type uint32; | | type uint32; |
| description | | description |
| "Hash value for attribute structure"; | | "Hash value for attribute structure"; |
| } | | } |
| leaf reference-count { | | leaf reference-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of paths which use this attribute | | "Number of paths which use this attribute |
| structure"; | | structure"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPD-FILTERGRP { | | grouping BGP-UPD-FILTERGRP { |
| description | | description |
| "Update filter-group entry"; | | "Update filter-group entry"; |
| leaf update-filter-group-number { | | leaf update-filter-group-number { |
| type uint32; | | type uint32; |
| description | | description |
| "Update sub-group index"; | | "Update sub-group index"; |
| } | | } |
| leaf rts { | | leaf rts { |
| type uint32; | | type uint32; |
| description | | description |
| "RT count per filter group"; | | "RT count per filter group"; |
| } | | } |
| leaf fgroup-flags { | | leaf fgroup-flags { |
| type uint8; | | type uint8; |
| description | | description |
| "Flags per filter group"; | | "Flags per filter group"; |
| } | | } |
| leaf fgroup-neighbors { | | leaf fgroup-neighbors { |
| type uint16; | | type uint16; |
| description | | description |
| "Nbrs per filter group"; | | "Nbrs per filter group"; |
| } | | } |
| leaf fgroup-created-message-elements { | | leaf fgroup-created-message-elements { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of message elems created for filtergroup"; | | "Number of message elems created for filtergroup"; |
| } | | } |
| leaf fgroup-deleted-message-elements { | | leaf fgroup-deleted-message-elements { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of message elems deleted"; | | "Number of message elems deleted"; |
| } | | } |
| leaf fgroup-queued-message-elements { | | leaf fgroup-queued-message-elements { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of message elems queued"; | | "Number of message elems queued"; |
| } | | } |
| leaf fgroup-advertised-prefixes { | | leaf fgroup-advertised-prefixes { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of prefixes advertised to filtergroup in | | "Number of prefixes advertised to filtergroup in |
| last update walk"; | | last update walk"; |
| } | | } |
| leaf fgroup-total-advertised-prefixes { | | leaf fgroup-total-advertised-prefixes { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of prefixes advertised to filtergroup in | | "Number of prefixes advertised to filtergroup in |
| all update walk"; | | all update walk"; |
| } | | } |
| leaf fgroup-withdrawn-prefixes { | | leaf fgroup-withdrawn-prefixes { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of prefixes withdrawn f`rom filtergroupin | | "Number of prefixes withdrawn f`rom filtergroupin |
| last update walk"; | | last update walk"; |
| } | | } |
| leaf fgroup-total-withdrawn-prefixes { | | leaf fgroup-total-withdrawn-prefixes { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of prefixes withdrawn f`rom filtergroupin | | "Number of prefixes withdrawn f`rom filtergroupin |
| all update walk"; | | all update walk"; |
| } | | } |
| leaf fgroup-total-non-optimised-prefixes { | | leaf fgroup-total-non-optimised-prefixes { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of prefixes non-optm from filtergroupin | | "Number of prefixes non-optm from filtergroupin |
| all update walk"; | | all update walk"; |
| } | | } |
| leaf fgroup-skipped-prefixes { | | leaf fgroup-skipped-prefixes { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of prefixes skipped for filtergroup in | | "Number of prefixes skipped for filtergroup in |
| last update walk"; | | last update walk"; |
| } | | } |
| leaf fgroup-suppressed-prefixes { | | leaf fgroup-suppressed-prefixes { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of prefixes suppressed for filtergroup in | | "Number of prefixes suppressed for filtergroup in |
| last update walk"; | | last update walk"; |
| } | | } |
| leaf is-rt-present { | | leaf is-rt-present { |
| type boolean; | | type boolean; |
| description | | description |
| "RT attribute list present"; | | "RT attribute list present"; |
| } | | } |
| list extended-community { | | list extended-community { |
| description | | description |
| "Extended community attribute"; | | "Extended community attribute"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "Extended community attribute"; | | "Extended community attribute"; |
| } | | } |
| } | | } |
| list neighbor { | | list neighbor { |
| description | | description |
| "Neighbors in this update sub-group"; | | "Neighbors in this update sub-group"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPD-SUBGRP { | | grouping BGP-UPD-SUBGRP { |
| description | | description |
| "Update sub-group entry"; | | "Update sub-group entry"; |
| leaf update-sub-group-number { | | leaf update-sub-group-number { |
| type uint32; | | type uint32; |
| description | | description |
| "Update sub-group index"; | | "Update sub-group index"; |
| } | | } |
| leaf filter-group { | | leaf filter-group { |
| type uint16; | | type uint16; |
| description | | description |
| "Update sub-group fgrp-num"; | | "Update sub-group fgrp-num"; |
| } | | } |
| leaf wait-for-eo-rs { | | leaf wait-for-eo-rs { |
| type boolean; | | type boolean; |
| description | | description |
| "Wait for RT Nbr EoRs"; | | "Wait for RT Nbr EoRs"; |
| } | | } |
| list update-filter-group { | | list update-filter-group { |
| description | | description |
| "Update f-group list"; | | "Update f-group list"; |
| uses BGP-UPD-FILTERGRP; | | uses BGP-UPD-FILTERGRP; |
| } | | } |
| list neighbor { | | list neighbor { |
| description | | description |
| "Neighbors in this subgrp not in any filtergrp"; | | "Neighbors in this subgrp not in any filtergrp"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| } | | } |
| | | |
| n | grouping BGP-PROCESS-WDR-STATS { | n | |
| description | | |
| "BGP Withdraw Stats info"; | | |
| container last-updated-time { | | |
| description | | |
| "Last update time"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| leaf not-advertised-count { | | |
| type uint32; | | |
| description | | |
| "Not advertised count"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-PERF-UPDGRP { | | grouping BGP-PERF-UPDGRP { |
| description | | description |
| "BGP PERF UPDGRP"; | | "BGP PERF UPDGRP"; |
| leaf update-generation-calls { | | leaf update-generation-calls { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of calls to update generation function"; | | "No. of calls to update generation function"; |
| } | | } |
| leaf update-generation-prefixes-count { | | leaf update-generation-prefixes-count { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of prefixes updates generated for"; | | "No. of prefixes updates generated for"; |
| } | | } |
| leaf update-generation-be-prefixes-count { | | leaf update-generation-be-prefixes-count { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of be prefixes updates generated for"; | | "No. of be prefixes updates generated for"; |
| } | | } |
| leaf update-generation-messages-count { | | leaf update-generation-messages-count { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of update messages generated"; | | "No. of update messages generated"; |
| } | | } |
| leaf update-generation-time { | | leaf update-generation-time { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Time spent generating updates (milliseconds)"; | | "Time spent generating updates (milliseconds)"; |
| } | | } |
| leaf updgen-timer-start-time { | | leaf updgen-timer-start-time { |
| type uint64; | | type uint64; |
| description | | description |
| "Timestamp when update timer started for updgrp"; | | "Timestamp when update timer started for updgrp"; |
| } | | } |
| leaf updgen-timer-stop-time { | | leaf updgen-timer-stop-time { |
| type uint64; | | type uint64; |
| description | | description |
| "Timestamp when update timer stopped for updgrp"; | | "Timestamp when update timer stopped for updgrp"; |
| } | | } |
| leaf updgen-timer-process-time { | | leaf updgen-timer-process-time { |
| type uint64; | | type uint64; |
| description | | description |
| "Timestamp when update timer processed for updgrp"; | | "Timestamp when update timer processed for updgrp"; |
| } | | } |
| n | list not-advertised-stat { | n | |
| max-elements "35"; | | |
| description | | |
| "Not Advertised Statistics"; | | |
| uses BGP-PROCESS-WDR-STATS; | | |
| } | | |
| } | | } |
| | | |
| grouping BGP-UPDGRP-BAG { | | grouping BGP-UPDGRP-BAG { |
| description | | description |
| "BGP Update Group information"; | | "BGP Update Group information"; |
| container performance-statistics { | | container performance-statistics { |
| description | | description |
| n | "Aggregated performance statisticsacross all VRFs | n | "Performance statistics"; |
| belonging to theparent address family"; | | |
| uses BGP-PERF-UPDGRP; | | uses BGP-PERF-UPDGRP; |
| } | | } |
| leaf process-instance-id { | | leaf process-instance-id { |
| type uint8; | | type uint8; |
| description | | description |
| n | "Instance ID of the BGP processwhere the path | n | "Process instance ID"; |
| originated"; | | |
| } | | } |
| leaf session-af-name { | | leaf session-af-name { |
| type uint8; | | type uint8; |
| description | | description |
| "Neighbor session Address family"; | | "Neighbor session Address family"; |
| } | | } |
| leaf update-group-number { | | leaf update-group-number { |
| type uint32; | | type uint32; |
| description | | description |
| "Update group index"; | | "Update group index"; |
| } | | } |
| leaf update-group-af-name { | | leaf update-group-af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Address family for update group"; | | "Address family for update group"; |
| } | | } |
| leaf should-send-communities { | | leaf should-send-communities { |
| type boolean; | | type boolean; |
| description | | description |
| "Send communities"; | | "Send communities"; |
| } | | } |
| leaf should-send-ext-communities { | | leaf should-send-ext-communities { |
| type boolean; | | type boolean; |
| description | | description |
| "Send Extended communities"; | | "Send Extended communities"; |
| } | | } |
| leaf should-send-stitching-rt { | | leaf should-send-stitching-rt { |
| type boolean; | | type boolean; |
| description | | description |
| "Send Stitching RT"; | | "Send Stitching RT"; |
| } | | } |
| leaf has-orf-receive-capability { | | leaf has-orf-receive-capability { |
| type boolean; | | type boolean; |
| description | | description |
| "ORF receive capability"; | | "ORF receive capability"; |
| } | | } |
| leaf is-route-reflector-client { | | leaf is-route-reflector-client { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if peers in this update group | n | |
| are route-reflector clients"; | | "Route-reflector client"; |
| } | | } |
| leaf is-client-reflection-disabled { | | leaf is-client-reflection-disabled { |
| type boolean; | | type boolean; |
| description | | description |
| "True if client-to-client reflection is disabled "; | | "True if client-to-client reflection is disabled "; |
| } | | } |
| leaf accepts-legacy-pe-rt-route { | | leaf accepts-legacy-pe-rt-route { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if provider edge device as a | n | "accept-legacy-pe-RT route"; |
| legacy for the route target"; | | |
| } | | } |
| leaf updgrp-cluster-id { | | leaf updgrp-cluster-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Cluster ID (populated ifclient-to-client | | "Cluster ID (populated ifclient-to-client |
| reflectionis disabled)"; | | reflectionis disabled)"; |
| } | | } |
| leaf updgrp-cluster-type { | | leaf updgrp-cluster-type { |
| type uint8; | | type uint8; |
| description | | description |
| "Cluster ID type:undefined/number/Ip address"; | | "Cluster ID type:undefined/number/Ip address"; |
| } | | } |
| leaf orr-group-name { | | leaf orr-group-name { |
| type string; | | type string; |
| description | | description |
| "ORR Group Name"; | | "ORR Group Name"; |
| } | | } |
| leaf orr-group-index { | | leaf orr-group-index { |
| type uint32; | | type uint32; |
| description | | description |
| "ORR Group Index"; | | "ORR Group Index"; |
| } | | } |
| leaf is-orr-root-address-configured { | | leaf is-orr-root-address-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "ORR Root address configuredfor the neighbor | | "ORR Root address configuredfor the neighbor |
| connection"; | | connection"; |
| } | | } |
| leaf should-remove-private-a-ss { | | leaf should-remove-private-a-ss { |
| type boolean; | | type boolean; |
| description | | description |
| "Remove private AS numbers"; | | "Remove private AS numbers"; |
| } | | } |
| leaf should-remove-private-as-ent-path { | | leaf should-remove-private-as-ent-path { |
| type boolean; | | type boolean; |
| description | | description |
| "Remove private AS numbersif the entire path | | "Remove private AS numbersif the entire path |
| consistsof private ASes"; | | consistsof private ASes"; |
| } | | } |
| leaf use-next-hop-self { | | leaf use-next-hop-self { |
| type boolean; | | type boolean; |
| description | | description |
| "Next hop self"; | | "Next hop self"; |
| } | | } |
| leaf use-next-hop-unchanged-mpath { | | leaf use-next-hop-unchanged-mpath { |
| type boolean; | | type boolean; |
| description | | description |
| n | "This update group have | n | |
| next-hop-unchangedmultipath configured"; | | "Next-hop-unchanged multipath"; |
| } | | } |
| leaf is-internal-peers { | | leaf is-internal-peers { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Peers in this update groupare internal"; | n | "Internal peers"; |
| } | | } |
| leaf is-common-admin-peers { | | leaf is-common-admin-peers { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if peers are undercommon | n | "Common admin peers"; |
| administration in BGP update group"; | | |
| } | | } |
| leaf is4-byte-as-peer { | | leaf is4-byte-as-peer { |
| type boolean; | | type boolean; |
| description | | description |
| "4-byte AS capable peers"; | | "4-byte AS capable peers"; |
| } | | } |
| leaf is-addpath-capable { | | leaf is-addpath-capable { |
| type boolean; | | type boolean; |
| description | | description |
| "Add-path capable peers"; | | "Add-path capable peers"; |
| } | | } |
| leaf is-send-mcast-attr-enabled { | | leaf is-send-mcast-attr-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if protocol independent | n | "Send mcast attribute enabled"; |
| multicast attributes are sent in this update | | |
| group"; | | |
| } | | } |
| leaf is-aigp-capable { | | leaf is-aigp-capable { |
| type boolean; | | type boolean; |
| description | | description |
| "AIGP capable peers"; | | "AIGP capable peers"; |
| } | | } |
| leaf is-aigp-cost-community-capable { | | leaf is-aigp-cost-community-capable { |
| type boolean; | | type boolean; |
| description | | description |
| "Send AIGP cost community to peers"; | | "Send AIGP cost community to peers"; |
| } | | } |
| leaf is-aigp-med-capable { | | leaf is-aigp-med-capable { |
| type boolean; | | type boolean; |
| description | | description |
| "Send AIGP cost in MED"; | | "Send AIGP cost in MED"; |
| } | | } |
| leaf is-llgr-capable { | | leaf is-llgr-capable { |
| type boolean; | | type boolean; |
| description | | description |
| "Send Long-lived Stale paths"; | | "Send Long-lived Stale paths"; |
| } | | } |
| leaf is-adv-capable { | | leaf is-adv-capable { |
| type boolean; | | type boolean; |
| description | | description |
| "Send tranlsated paths"; | | "Send tranlsated paths"; |
| } | | } |
| leaf is-adv-reorg-capable { | | leaf is-adv-reorg-capable { |
| type boolean; | | type boolean; |
| description | | description |
| "Send Re-orig paths"; | | "Send Re-orig paths"; |
| } | | } |
| leaf disable-native-advertisement { | | leaf disable-native-advertisement { |
| type boolean; | | type boolean; |
| description | | description |
| "Disable advertising native routes"; | | "Disable advertising native routes"; |
| } | | } |
| leaf disable-def-vrf-imp-advertisement { | | leaf disable-def-vrf-imp-advertisement { |
| type boolean; | | type boolean; |
| description | | description |
| "Disable advertising default VRF imported routes"; | | "Disable advertising default VRF imported routes"; |
| } | | } |
| leaf disable-vrf-re-imp-advertisement { | | leaf disable-vrf-re-imp-advertisement { |
| type boolean; | | type boolean; |
| description | | description |
| "Disable advertising VRF re-imported routes"; | | "Disable advertising VRF re-imported routes"; |
| } | | } |
| leaf encapsulation-type { | | leaf encapsulation-type { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP update group encapsulation type"; | n | "Encapsulation type"; |
| } | | } |
| leaf advertise-rt-type { | | leaf advertise-rt-type { |
| type uint8; | | type uint8; |
| description | | description |
| n | "BGP update group toadvertise route target type"; | n | "Advertise RT type"; |
| } | | } |
| leaf is-directly-connected-ebgp-v6-peers { | | leaf is-directly-connected-ebgp-v6-peers { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate an update group is directly | n | |
| connected eBGP peers"; | | "Directly connected EBGP v6 peers"; |
| } | | } |
| leaf minimum-advertisement-interval { | | leaf minimum-advertisement-interval { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| n | "Minimum advert time for peers in this | n | "Minimum advertisement interval, secs part"; |
| update-group in seconds"; | | |
| } | | } |
| leaf minimum-advertisement-interval-msecs { | | leaf minimum-advertisement-interval-msecs { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| n | "Minimum advert time for peers inthis update | n | "Minimum advertisement interval, msecs part"; |
| group in milliseconds"; | | |
| } | | } |
| leaf local-as { | | leaf local-as { |
| type uint32; | | type uint32; |
| description | | description |
| "Local AS number"; | | "Local AS number"; |
| } | | } |
| leaf route-policy-out { | | leaf route-policy-out { |
| type string; | | type string; |
| description | | description |
| "Outbound route policy name"; | | "Outbound route policy name"; |
| } | | } |
| leaf desync-count { | | leaf desync-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of times the update has been | | "Number of times the update has been |
| desynchronized"; | | desynchronized"; |
| } | | } |
| leaf subgrp-merge-count { | | leaf subgrp-merge-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of times sub-groups have been merged"; | | "Number of times sub-groups have been merged"; |
| } | | } |
| leaf refresh-subgrp-count { | | leaf refresh-subgrp-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Current count of refresh subgroups"; | | "Current count of refresh subgroups"; |
| } | | } |
| leaf updates-formatted { | | leaf updates-formatted { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of updates formatted"; | | "Number of updates formatted"; |
| } | | } |
| leaf updates-replicated { | | leaf updates-replicated { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of updates replicatedfor BGP update group"; | n | "No. of updates replicated"; |
| } | | } |
| leaf local-as-replace-as { | | leaf local-as-replace-as { |
| type boolean; | | type boolean; |
| description | | description |
| "Local AS Replace-AS option"; | | "Local AS Replace-AS option"; |
| } | | } |
| leaf as-override { | | leaf as-override { |
| type boolean; | | type boolean; |
| description | | description |
| "AS Override option"; | | "AS Override option"; |
| } | | } |
| leaf soo-value { | | leaf soo-value { |
| type string; | | type string; |
| description | | description |
| "Site-of-origin value"; | | "Site-of-origin value"; |
| } | | } |
| leaf split-horizon { | | leaf split-horizon { |
| type boolean; | | type boolean; |
| description | | description |
| "Split horizon check"; | | "Split horizon check"; |
| } | | } |
| leaf is-labeled-afi-enabled { | | leaf is-labeled-afi-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Update group has labeled AFI enabled"; | | "Update group has labeled AFI enabled"; |
| } | | } |
| leaf is-unlabeled-afi-enabled { | | leaf is-unlabeled-afi-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Update group has unlabeled AFI enabled"; | | "Update group has unlabeled AFI enabled"; |
| } | | } |
| leaf ext-nh-encoding { | | leaf ext-nh-encoding { |
| type boolean; | | type boolean; |
| description | | description |
| "Extended nexthop encoding cap received"; | | "Extended nexthop encoding cap received"; |
| } | | } |
| leaf remote-as { | | leaf remote-as { |
| type uint32; | | type uint32; |
| description | | description |
| "Remote AS number"; | | "Remote AS number"; |
| } | | } |
| leaf is-adv-perm-net-capable { | | leaf is-adv-perm-net-capable { |
| type boolean; | | type boolean; |
| description | | description |
| "Advertise Permanent-Net capable peers"; | | "Advertise Permanent-Net capable peers"; |
| } | | } |
| leaf should-send-gshut-community { | | leaf should-send-gshut-community { |
| type boolean; | | type boolean; |
| description | | description |
| "Send GSHUT community"; | | "Send GSHUT community"; |
| } | | } |
| leaf gshut-active { | | leaf gshut-active { |
| type boolean; | | type boolean; |
| description | | description |
| "GSHUT active"; | | "GSHUT active"; |
| } | | } |
| leaf gshut-locpref-set { | | leaf gshut-locpref-set { |
| type boolean; | | type boolean; |
| description | | description |
| "GSHUT local preference set"; | | "GSHUT local preference set"; |
| } | | } |
| leaf gshut-locpref { | | leaf gshut-locpref { |
| type uint32; | | type uint32; |
| description | | description |
| "GSHUT local preference"; | | "GSHUT local preference"; |
| } | | } |
| leaf gshut-prepends { | | leaf gshut-prepends { |
| type uint8; | | type uint8; |
| description | | description |
| "GSHUT AS prepends"; | | "GSHUT AS prepends"; |
| } | | } |
| leaf advertise-local-labeled-route-unicast { | | leaf advertise-local-labeled-route-unicast { |
| type boolean; | | type boolean; |
| description | | description |
| "Advertise routes with local-label via Unicast | | "Advertise routes with local-label via Unicast |
| SAFI"; | | SAFI"; |
| } | | } |
| leaf enable-label-stack { | | leaf enable-label-stack { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Enable BGP upgrade group label stack"; | n | "Enable label stack"; |
| } | | |
| leaf contains-static-slow-peer { | | |
| type boolean; | | |
| description | | |
| "This update group contains static slow peers"; | | |
| } | | |
| leaf advertise-entropy-label-disable { | | |
| type boolean; | | |
| description | | |
| "Disable propagation of entropy label to this | | |
| peer"; | | |
| } | | |
| leaf should-replace-private-a-ss { | | |
| type boolean; | | |
| description | | |
| "Replace private AS numbers"; | | |
| } | | |
| leaf default-policy-action-out-accept { | | |
| type boolean; | | |
| description | | |
| "Default Policy Out Action Configured as Accept"; | | |
| } | | |
| leaf evpn-gateway-ip-advertisement-disable { | | |
| type boolean; | | |
| description | | |
| "Disable Advertisement of non-zero EVPN Gateway | | |
| IP"; | | |
| } | | } |
| list neighbor { | | list neighbor { |
| description | | description |
| "Neighbors in this update group which are not in | | "Neighbors in this update group which are not in |
| any sub-group"; | | any sub-group"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| list update-sub-group { | | list update-sub-group { |
| description | | description |
| n | "List of child refresh subgroups inBGP update | n | "Update sub-group list"; |
| group"; | | |
| uses BGP-UPD-SUBGRP; | | uses BGP-UPD-SUBGRP; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-STATIC-ROUTES-BAG { | | grouping BGP-STATIC-ROUTES-BAG { |
| description | | description |
| "BGP static routes information"; | | "BGP static routes information"; |
| container sourced-prefix { | | container sourced-prefix { |
| description | | description |
| "Prefix length"; | | "Prefix length"; |
| uses BGP-PREFIXTYPE; | | uses BGP-PREFIXTYPE; |
| } | | } |
| leaf af-name { | | leaf af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Address family identifier"; | | "Address family identifier"; |
| } | | } |
| leaf is-backdoor { | | leaf is-backdoor { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if net is a backdoor route"; | | "TRUE if net is a backdoor route"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-GLOBAL-PROCESS-INFO-AF-VRF { | | grouping BGP-GLOBAL-PROCESS-INFO-AF-VRF { |
| description | | description |
| "BGP GLOBAL PROCESS INFO AF VRF"; | | "BGP GLOBAL PROCESS INFO AF VRF"; |
| leaf table-is-active { | | leaf table-is-active { |
| type boolean; | | type boolean; |
| description | | description |
| "Table state is active"; | | "Table state is active"; |
| } | | } |
| leaf table-id { | | leaf table-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Table ID"; | | "Table ID"; |
| } | | } |
| leaf def-orig-enabled { | | leaf def-orig-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Default Orig enabled for a vrf afi"; | | "Default Orig enabled for a vrf afi"; |
| } | | } |
| leaf table-version { | | leaf table-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| n | "BGP global process table version info"; | n | "Table version"; |
| } | | } |
| leaf rd-version { | | leaf rd-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "RD version"; | | "RD version"; |
| } | | } |
| leaf rib-version { | | leaf rib-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Table version synced to RIB"; | | "Table version synced to RIB"; |
| } | | } |
| leaf nsr-conv-version { | | leaf nsr-conv-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| n | "Cache for non stop routingcurrent table version"; | n | "NSR conv version"; |
| } | | } |
| leaf nsr-is-conv { | | leaf nsr-is-conv { |
| type boolean; | | type boolean; |
| description | | description |
| "NSR is converged"; | | "NSR is converged"; |
| } | | } |
| leaf client-reflection-enabled { | | leaf client-reflection-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if client-to-client reflection | n | "Client reflection enabled"; |
| is enabled"; | | |
| } | | } |
| leaf dampening-enabled { | | leaf dampening-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to enable BGP address-family dampening"; | n | "Dampening enabled"; |
| } | | } |
| leaf ebgp-distance { | | leaf ebgp-distance { |
| type uint16; | | type uint16; |
| description | | description |
| "Distance for eBGP routes (external)"; | | "Distance for eBGP routes (external)"; |
| } | | } |
| leaf ibgp-distance { | | leaf ibgp-distance { |
| type uint16; | | type uint16; |
| description | | description |
| "Distance for iBGP routes (internal)"; | | "Distance for iBGP routes (internal)"; |
| } | | } |
| leaf aggregates-distance { | | leaf aggregates-distance { |
| type uint16; | | type uint16; |
| description | | description |
| "Dist for aggregate routes (local)"; | | "Dist for aggregate routes (local)"; |
| } | | } |
| leaf dynamic-med-enabled { | | leaf dynamic-med-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Update generation enabled for MED change"; | | "Update generation enabled for MED change"; |
| } | | } |
| leaf dynamic-med-interval { | | leaf dynamic-med-interval { |
| type uint16; | | type uint16; |
| units "minute"; | | units "minute"; |
| description | | description |
| "Delay in update generation after a MED change | | "Delay in update generation after a MED change |
| (in minutes)"; | | (in minutes)"; |
| } | | } |
| leaf dynamic-med-timer-running { | | leaf dynamic-med-timer-running { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if dynamic multi exit | n | "Dynamic MED timer running"; |
| discriminator (MED) timer is running"; | | |
| } | | } |
| leaf dynamic-med-timer-value { | | leaf dynamic-med-timer-value { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "Dynamic MED timer value (in seconds) left on the | | "Dynamic MED timer value (in seconds) left on the |
| timer"; | | timer"; |
| } | | } |
| leaf dynamic-med-periodic-timer-running { | | leaf dynamic-med-periodic-timer-running { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Dynamic multi exit discriminatorperiodic timer | n | "Dynamic MED periodic timer running"; |
| running"; | | |
| } | | } |
| leaf dynamic-med-periodic-timer-value { | | leaf dynamic-med-periodic-timer-value { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "Dynamic MED periodic timer value (in seconds) | | "Dynamic MED periodic timer value (in seconds) |
| left on the timer"; | | left on the timer"; |
| } | | } |
| leaf rib-has-converged { | | leaf rib-has-converged { |
| type boolean; | | type boolean; |
| description | | description |
| "Received convergence notification from RIB"; | | "Received convergence notification from RIB"; |
| } | | } |
| leaf rib-convergence-version { | | leaf rib-convergence-version { |
| type uint32; | | type uint32; |
| description | | description |
| "Last convergence version received from RIB"; | | "Last convergence version received from RIB"; |
| } | | } |
| leaf is-rib-table-full { | | leaf is-rib-table-full { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates if RIB table is in prefix-limit state"; | | "Indicates if RIB table is in prefix-limit state"; |
| } | | } |
| leaf rib-table-full-version { | | leaf rib-table-full-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Version when RIB table became full (from | | "Version when RIB table became full (from |
| non-full)"; | | non-full)"; |
| } | | } |
| n | leaf is-unique-nexthop-check-disabled { | n | |
| type boolean; | | |
| description | | |
| "Indicates if unique nexthop check disabled"; | | |
| } | | |
| leaf nexthop-resolution-minimum-prefix-length-configured { | | leaf nexthop-resolution-minimum-prefix-length-configured { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if nexthop resolution minimum | n | "Is nexthop resoultion minimum prefix-length |
| prefix-length is configured"; | | configured ?"; |
| } | | } |
| leaf nexthop-resolution-minimum-prefix-length { | | leaf nexthop-resolution-minimum-prefix-length { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Used to validate prefix-length of resolving | n | "Nexthop resoultion minimum prefix-length"; |
| route of nexthopsin BGP"; | | |
| } | | |
| leaf ipv6-nexthop-resolution-minimum-prefix-length-configured { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if ipv6 nexthop resolution | | |
| minimum prefix-length is configured"; | | |
| } | | |
| leaf ipv6-nexthop-resolution-minimum-prefix-length { | | |
| type uint32; | | |
| description | | |
| "Used to validate prefix-length of resolving | | |
| route of ipv6 nexthopsin BGP"; | | |
| } | | } |
| leaf selective-ebgp-multipath-enabled { | | leaf selective-ebgp-multipath-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if the Selective option is | n | "Selective eBGP multipath isenabled"; |
| configured with multipath external bgp"; | | |
| } | | } |
| leaf selective-ibgp-multipath-enabled { | | leaf selective-ibgp-multipath-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if the Selective option is | n | "Selective iBGP multipath isenabled"; |
| configured with multipath internal bgp"; | | |
| } | | } |
| leaf selective-eibgp-multipath-enabled { | | leaf selective-eibgp-multipath-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if the Selective option is | n | "Selective eiBGP multipath isenabled"; |
| configured with multipath external internal bgp"; | | |
| } | | |
| leaf deterministic-ibgp-multipath-enabled { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate if Deterministic option is | | |
| configured with multipath internal bgp"; | | |
| } | | } |
| leaf rib-acked-table-version { | | leaf rib-acked-table-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Table version acked by RIB"; | | "Table version acked by RIB"; |
| n | } | n | |
| leaf vrf-srv6-sid-alloc-mode { | | |
| type uint32; | | |
| description | | |
| "SID alloc mode of SRv6 under Vrf"; | | |
| } | | |
| leaf isvrf-srv6-enabled { | | |
| type boolean; | | |
| description | | |
| "SRv6 info under a Vrf"; | | |
| } | | |
| leaf vrf-usid-alloc-mode { | | |
| type Bgp-usid-alloc-mode; | | |
| description | | |
| "uSID LIB allocation mode under a Vrf"; | | |
| } | | |
| leaf vrf-srv6-locator { | | |
| type string; | | |
| description | | |
| "SRv6 Locator Name under Vrf"; | | |
| } | | |
| leaf vrf-all-srv6-locator { | | |
| type string; | | |
| description | | |
| "SRv6 Locator Name under Vrf All"; | | |
| } | | |
| leaf vrf-all-srv6-sid-alloc-mode { | | |
| type uint32; | | |
| description | | |
| "SRv6 SID alloc mode under Vrf All"; | | |
| } | | |
| leaf isvrfall-srv6-enabled { | | |
| type boolean; | | |
| description | | |
| "SRv6 info under a Vrf All"; | | |
| } | | |
| leaf vrf-all-usid-alloc-mode { | | |
| type Bgp-usid-alloc-mode; | | |
| description | | |
| "uSID LIB allocation mode under Vrf All"; | | |
| } | | |
| leaf rpki-version { | | |
| type uint64; | | |
| description | | |
| "RPKI table version walked"; | | |
| } | | |
| leaf rpki-soft-reconf-version { | | |
| type uint64; | | |
| description | | |
| "RPKI soft reconfiguration version walked"; | | |
| } | | |
| leaf nexthop-policy { | | |
| type string; | | |
| description | | |
| "Nexthop route policy"; | | |
| } | | |
| leaf label-alloc-mode { | | |
| type uint32; | | |
| description | | |
| "MPLS Label alloc mode under VRF"; | | |
| } | | |
| leaf vrf-all-label-alloc-mode { | | |
| type uint32; | | |
| description | | |
| "MPLS Label alloc mode under VRF all"; | | |
| } | | |
| leaf pfx-dwld-delay { | | |
| type uint32; | | |
| description | | |
| "Prefix Download Delay"; | | |
| } | | |
| leaf oor-threshold { | | |
| type uint32; | | |
| description | | |
| "OOR threshold for prefix download delay"; | | |
| } | | |
| leaf oor-flag { | | |
| type boolean; | | |
| description | | |
| "OOR Flag"; | | |
| } | | |
| list oc-rib-out-attr-pool-size { | | |
| max-elements "10"; | | |
| description | | |
| "Memory size for each OCRIB Out attributes chunk"; | | |
| leaf entry { | | |
| type uint32; | | |
| description | | |
| "Memory size for each OCRIB Out attributes chunk"; | | |
| } | | |
| } | | |
| list oc-rib-out-attr-pool-alloc-count { | | |
| max-elements "10"; | | |
| description | | |
| "Number of OCRIB Out Attributes allocated per | | |
| | | |
| pool"; | | |
| leaf entry { | | |
| type uint32; | | |
| description | | |
| "Number of OCRIB Out Attributes allocated per | | |
| | | |
| pool"; | | |
| } | | |
| } | | |
| list oc-rib-out-attr-pool-free-count { | | |
| max-elements "10"; | | |
| description | | |
| "Number of OCRIB Out Attributes freed per pool"; | | |
| leaf entry { | | |
| type uint32; | | |
| description | | |
| "Number of OCRIB Out Attributes freed per pool"; | | |
| } | | |
| } | | |
| list oc-rib-path-count-per-out-attribute { | | |
| description | | |
| "Current Number of paths having particular number | | |
| | | |
| of outbound attributes"; | | |
| leaf entry { | | |
| type uint32; | | |
| description | | |
| "Current Number of paths having particular number | | |
| | | |
| of outbound attributes"; | | |
| } | | |
| } | | } |
| } | | } |
| | | |
| grouping BGP-GLOBAL-PROCESS-INFO-AF-GBL { | | grouping BGP-GLOBAL-PROCESS-INFO-AF-GBL { |
| description | | description |
| "BGP GLOBAL PROCESS INFO AF GBL"; | | "BGP GLOBAL PROCESS INFO AF GBL"; |
| container rib-install { | | container rib-install { |
| description | | description |
| "RIB install info"; | | "RIB install info"; |
| uses BGP-RIB-INSTALL-TIME-INFO; | | uses BGP-RIB-INSTALL-TIME-INFO; |
| n | } | n | |
| container nets-rpki-sanitized-timestamp { | | |
| description | | |
| "timestamp of last RPKI sanitized net"; | | |
| uses BGP-TIMESPEC; | | |
| } | | } |
| leaf scanner-period { | | leaf scanner-period { |
| type uint16; | | type uint16; |
| units "second"; | | units "second"; |
| description | | description |
| "Period (in seconds) of address-family scanner | | "Period (in seconds) of address-family scanner |
| runs"; | | runs"; |
| } | | } |
| leaf nh-tunnel-version { | | leaf nh-tunnel-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "NH Tunnel Version"; | | "NH Tunnel Version"; |
| } | | } |
| leaf scan-prefixes { | | leaf scan-prefixes { |
| type uint32; | | type uint32; |
| description | | description |
| "Total prefixes of address-family scanned"; | | "Total prefixes of address-family scanned"; |
| } | | } |
| leaf scan-segment-prefixes { | | leaf scan-segment-prefixes { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of prefixes scanned in a segment of | | "Number of prefixes scanned in a segment of |
| address-family"; | | address-family"; |
| } | | } |
| leaf scan-segments { | | leaf scan-segments { |
| type uint8; | | type uint8; |
| description | | description |
| "Number of segments to scan all prefixes of | | "Number of segments to scan all prefixes of |
| address-family"; | | address-family"; |
| } | | } |
| leaf inter-as-install-enabled { | | leaf inter-as-install-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Is inter-AS install to pim on ASBR enabled"; | | "Is inter-AS install to pim on ASBR enabled"; |
| } | | } |
| leaf global-mcast-enabled { | | leaf global-mcast-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if global routing table | n | "Is global table mcast enabled"; |
| multicast is enabled"; | | |
| } | | } |
| leaf segmented-mcast-enabled { | | leaf segmented-mcast-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if BGP segmented multicast is | n | "Is segmented mcast enabled"; |
| enabled"; | | |
| } | | } |
| leaf gblafrpki-disable { | | leaf gblafrpki-disable { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix validation disabled"; | | "Prefix validation disabled"; |
| } | | } |
| leaf gblafrpki-use-validity { | | leaf gblafrpki-use-validity { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix v. use validity"; | | "Prefix v. use validity"; |
| } | | } |
| leaf gblafrpki-allow-invalid { | | leaf gblafrpki-allow-invalid { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix v. allow invalid"; | | "Prefix v. allow invalid"; |
| } | | } |
| leaf gblafrpki-signal-ibgp { | | leaf gblafrpki-signal-ibgp { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix v. signal ibgp"; | | "Prefix v. signal ibgp"; |
| } | | } |
| leaf update-wait-install-enabled { | | leaf update-wait-install-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to wait for installation update"; | n | "Update wait-install enabled"; |
| } | | |
| leaf update-wait-install-startup-delay { | | |
| type uint16; | | |
| units "second"; | | |
| description | | |
| "Update wait install startup delay in seconds"; | | |
| } | | } |
| leaf rib-ack-requests { | | leaf rib-ack-requests { |
| type uint32; | | type uint32; |
| description | | description |
| "Counter for RIB ack requests"; | | "Counter for RIB ack requests"; |
| } | | } |
| leaf rib-acks-received { | | leaf rib-acks-received { |
| type uint32; | | type uint32; |
| description | | description |
| "Counter for RIB ack received"; | | "Counter for RIB ack received"; |
| } | | } |
| leaf rib-slow-acks { | | leaf rib-slow-acks { |
| type uint32; | | type uint32; |
| description | | description |
| "Counter for slow RIB acks"; | | "Counter for slow RIB acks"; |
| } | | } |
| leaf is-perm-net-cfg { | | leaf is-perm-net-cfg { |
| type boolean; | | type boolean; |
| description | | description |
| "Permanent Network Enabled"; | | "Permanent Network Enabled"; |
| } | | } |
| leaf perm-net-del-count { | | leaf perm-net-del-count { |
| type uint16; | | type uint16; |
| description | | description |
| "Count of removed perm paths"; | | "Count of removed perm paths"; |
| } | | } |
| leaf perm-net-stale-del-count { | | leaf perm-net-stale-del-count { |
| type uint16; | | type uint16; |
| description | | description |
| "Count of stale perm paths"; | | "Count of stale perm paths"; |
| } | | } |
| leaf perm-net-stale-mark-count { | | leaf perm-net-stale-mark-count { |
| type uint16; | | type uint16; |
| description | | description |
| "Count of stale marked perm paths"; | | "Count of stale marked perm paths"; |
| } | | } |
| leaf perm-net-insert-count { | | leaf perm-net-insert-count { |
| type uint16; | | type uint16; |
| description | | description |
| "Count of inserted perm paths"; | | "Count of inserted perm paths"; |
| } | | } |
| leaf perm-net-existing-count { | | leaf perm-net-existing-count { |
| type uint16; | | type uint16; |
| description | | description |
| "Count of existing perm paths"; | | "Count of existing perm paths"; |
| } | | } |
| leaf perm-net-rpl-query-count { | | leaf perm-net-rpl-query-count { |
| type uint16; | | type uint16; |
| description | | description |
| "Count of perm nets given by RPL"; | | "Count of perm nets given by RPL"; |
| } | | } |
| leaf perm-net-rpl-process-count { | | leaf perm-net-rpl-process-count { |
| type uint16; | | type uint16; |
| description | | description |
| "Count of perm nets processed in RPL"; | | "Count of perm nets processed in RPL"; |
| } | | } |
| leaf perm-nbr-count { | | leaf perm-nbr-count { |
| type uint16; | | type uint16; |
| description | | description |
| "Count of neighbors configured with perm net"; | | "Count of neighbors configured with perm net"; |
| } | | } |
| leaf rib-perm-pelem-not-found-count { | | leaf rib-perm-pelem-not-found-count { |
| type uint16; | | type uint16; |
| description | | description |
| ""; | | ""; |
| } | | } |
| leaf rib-perm-path-not-found-count { | | leaf rib-perm-path-not-found-count { |
| type uint16; | | type uint16; |
| description | | description |
| ""; | | ""; |
| } | | } |
| leaf rib-perm-pelem-found-count { | | leaf rib-perm-pelem-found-count { |
| type uint16; | | type uint16; |
| description | | description |
| ""; | | ""; |
| } | | } |
| leaf rib-reg-path-found-count { | | leaf rib-reg-path-found-count { |
| type uint16; | | type uint16; |
| description | | description |
| ""; | | ""; |
| } | | } |
| leaf rib-perm-path-found-count { | | leaf rib-perm-path-found-count { |
| type uint16; | | type uint16; |
| description | | description |
| ""; | | ""; |
| } | | } |
| leaf perm-pelem-free-count { | | leaf perm-pelem-free-count { |
| type uint16; | | type uint16; |
| description | | description |
| "Count of freed perm pelems"; | | "Count of freed perm pelems"; |
| } | | } |
| leaf perm-path-refresh-count { | | leaf perm-path-refresh-count { |
| type uint16; | | type uint16; |
| description | | description |
| "Count of perm paths refreshed"; | | "Count of perm paths refreshed"; |
| } | | } |
| leaf perm-pelem-bump-count { | | leaf perm-pelem-bump-count { |
| type uint16; | | type uint16; |
| description | | description |
| "Count of bumped perm pelems"; | | "Count of bumped perm pelems"; |
| } | | } |
| leaf perm-pelem-all-bump-count { | | leaf perm-pelem-all-bump-count { |
| type uint16; | | type uint16; |
| description | | description |
| "Count of bumped perm pelems"; | | "Count of bumped perm pelems"; |
| } | | } |
| n | leaf af-srv6-sid-alloc-mode { | n | |
| type uint32; | | |
| description | | |
| "SID alloc mode of SRv6 under AF"; | | |
| } | | |
| leaf af-srv6-locator { | | |
| type string; | | |
| description | | |
| "SRv6 Locator Name under AF"; | | |
| } | | |
| leaf af-usid-alloc-mode { | | |
| type Bgp-usid-alloc-mode; | | |
| description | | |
| "uSID LIB allocation mode"; | | |
| } | | |
| leaf nets-rpki-sanitized { | | |
| type uint32; | | |
| description | | |
| "Count of nets that had RPKI validity repaired by | | |
| the background sanitizer"; | | |
| } | | |
| leaf scoped-sync-last-msg-failed-cnt { | | |
| type uint32; | | |
| description | | |
| "Num of time scoped sync last msg sent failure"; | | |
| } | | |
| leaf scoped-sync-last-msg-resumed-cnt { | | |
| type uint32; | | |
| description | | |
| "Num of time scoped sync resumed for last msg | | |
| failure"; | | |
| } | | |
| leaf scoped-sync-default-rt-stopped-cnt { | | |
| type uint32; | | |
| description | | |
| "Num of time scoped sync default RT stopped"; | | |
| } | | |
| leaf scoped-sync-default-rt-resumed-cnt { | | |
| type uint32; | | |
| description | | |
| "Num of time scoped sync default RT resumed"; | | |
| } | | |
| leaf scoped-sync-default-rt-lookup-failed-cnt { | | |
| type uint32; | | |
| description | | |
| "Num of time scoped sync default rt lookup failed"; | | |
| } | | |
| list syncgrp-version { | | list syncgrp-version { |
| max-elements "2"; | | max-elements "2"; |
| description | | description |
| "Sync-group Version"; | | "Sync-group Version"; |
| leaf entry { | | leaf entry { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Sync-group Version"; | | "Sync-group Version"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping BGP-GLOBAL-PROCESS-INFO-AF-BAG { | | grouping BGP-GLOBAL-PROCESS-INFO-AF-BAG { |
| description | | description |
| "BGP address family specific information common to | | "BGP address family specific information common to |
| all BGP processes"; | | all BGP processes"; |
| container global { | | container global { |
| description | | description |
| "Global information"; | | "Global information"; |
| uses BGP-GLOBAL-PROCESS-INFO-AF-GBL; | | uses BGP-GLOBAL-PROCESS-INFO-AF-GBL; |
| } | | } |
| container vrf { | | container vrf { |
| description | | description |
| "VRF information"; | | "VRF information"; |
| uses BGP-GLOBAL-PROCESS-INFO-AF-VRF; | | uses BGP-GLOBAL-PROCESS-INFO-AF-VRF; |
| } | | } |
| leaf vrf-name { | | leaf vrf-name { |
| type string; | | type string; |
| description | | description |
| "Name of the VRF"; | | "Name of the VRF"; |
| } | | } |
| leaf af-name { | | leaf af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Address family id"; | | "Address family id"; |
| } | | } |
| leaf is-nsr-enabled { | | leaf is-nsr-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Non-stop routing enabled"; | | "Non-stop routing enabled"; |
| } | | } |
| } | | } |
| | | |
| n | grouping BGP-RPC-NEXTHOPSET { | n | grouping BGP-RPC-SET-BAG { |
| | | description |
| | | "BGP RPC SET BAG"; |
| | | leaf next-hop-xr { |
| | | type uint32; |
| description | | description |
| "BGP RPC NEXTHOPSET"; | | "Number of multipath next-hops"; |
| container nexthop-addr { | | } |
| | | leaf label { |
| | | type uint32; |
| | | description |
| | | "Label assigned to the RPCnext-hop set"; |
| | | } |
| | | leaf ref-count { |
| | | type uint32; |
| | | description |
| | | "Refcount"; |
| | | } |
| | | leaf srv6sid-address { |
| | | type Ipv6-address; |
| | | description |
| | | "SRv6 SID address value"; |
| | | } |
| | | leaf srv6sid-address-len { |
| | | type uint32; |
| | | description |
| | | "SRv6 SID address Length"; |
| | | } |
| | | list next-hop { |
| description | | description |
| "List of multipath next-hops"; | | "List of multipath next-hops"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| n | leaf received-label { | n | |
| type uint32; | | |
| description | | |
| "Received labl for the path"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-RPC-SET-BAG { | | |
| description | | |
| "BGP RPC SET BAG"; | | |
| leaf next-hop-xr { | | |
| type uint32; | | |
| description | | |
| "Number of multipath next-hops"; | | |
| } | | |
| leaf label { | | |
| type uint32; | | |
| description | | |
| "Label assigned to the RPCnext-hop set"; | | |
| } | | |
| leaf ref-count { | | |
| type uint32; | | |
| description | | |
| "Reference for the count"; | | |
| } | | |
| leaf srv6-sid-address { | | |
| type Ipv6-address; | | |
| description | | |
| "SRv6 SID address value"; | | |
| } | | |
| leaf srv6-sid-address-len { | | |
| type uint32; | | |
| description | | |
| "SRv6 SID address Length"; | | |
| } | | |
| leaf locator-format { | | |
| type uint32; | | |
| description | | |
| "Locator Format"; | | |
| } | | |
| leaf retain-counter { | | |
| type uint8; | | |
| description | | |
| "RPC retain counter"; | | |
| } | | |
| list next-hop { | | |
| description | | |
| "List of multipath next-hops"; | | |
| uses BGP-RPC-NEXTHOPSET; | | |
| } | | |
| } | | } |
| | | |
| grouping BGP-BMP-TBL-GBL-BAG { | | grouping BGP-BMP-TBL-GBL-BAG { |
| description | | description |
| "BMP Table global information"; | | "BMP Table global information"; |
| n | | n | container bmp-version-wrap-time-spec { |
| | | description |
| | | "Version Wrap timestamp"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container bmp-version-wrap-start-time-spec { |
| | | description |
| | | "Version Wrap handle start timestamp"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container bmp-version-wrap-done-time-spec { |
| | | description |
| | | "Version Wrap handle Done timestamp"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| leaf bmp-route-monitoringe-enabled { | | leaf bmp-route-monitoringe-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Is Route Monitoring mode enabled"; | | "Is Route Monitoring mode enabled"; |
| } | | } |
| leaf bmp-table-version { | | leaf bmp-table-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Table version"; | | "Table version"; |
| } | | } |
| n | leaf rd-count { | n | |
| type uint32; | | |
| description | | |
| "Number of RDs in the table"; | | |
| } | | |
| leaf network-count { | | leaf network-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of nets in the table"; | | "Number of nets in the table"; |
| } | | } |
| leaf path-count { | | leaf path-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of paths in the table"; | | "Number of paths in the table"; |
| n | | n | } |
| | | leaf bmp-version-wrapped { |
| | | type uint32; |
| | | description |
| | | "Number of times Table Version Wrapped"; |
| | | } |
| | | leaf bmp-version-wrapped-tid { |
| | | type uint32; |
| | | description |
| | | "Version Wrapped trigger thread id"; |
| | | } |
| | | leaf bmp-version-inprogress { |
| | | type boolean; |
| | | description |
| | | "Is Version wrap in progress"; |
| | | } |
| | | leaf bmp-version-incremented { |
| | | type boolean; |
| | | description |
| | | "Is Version being incremented"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-PATH-BAG { | | grouping BGP-PATH-BAG { |
| description | | description |
| "BGP path"; | | "BGP path"; |
| container advertised-neighbor { | | container advertised-neighbor { |
| description | | description |
| "Advertised Neighbor Address. Valid in the case | | "Advertised Neighbor Address. Valid in the case |
| of Advertised table"; | | of Advertised table"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container path-information { | | container path-information { |
| description | | description |
| n | "BGP path information "; | n | "Path information"; |
| uses BGP-PATH; | | uses BGP-PATH; |
| } | | } |
| container attributes-after-policy-in { | | container attributes-after-policy-in { |
| description | | description |
| "Attributes after inbound policy applied. In the | | "Attributes after inbound policy applied. In the |
| case of path type received-only this will be | | case of path type received-only this will be |
| attributes before inbound policy"; | | attributes before inbound policy"; |
| uses BGP-ATTR; | | uses BGP-ATTR; |
| } | | } |
| leaf no-path { | | leaf no-path { |
| type boolean; | | type boolean; |
| description | | description |
| "No path exists. All 'sp_path' fields except | | "No path exists. All 'sp_path' fields except |
| 'sp_path->bag_prefix' are invalid"; | | 'sp_path->bag_prefix' are invalid"; |
| } | | } |
| leaf af-name { | | leaf af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Address family identifier"; | | "Address family identifier"; |
| } | | } |
| leaf process-instance-id { | | leaf process-instance-id { |
| type uint8; | | type uint8; |
| description | | description |
| n | "BGP Process instance ID"; | n | "Process instance ID"; |
| } | | } |
| leaf label-oor { | | leaf label-oor { |
| type boolean; | | type boolean; |
| description | | description |
| "LSD label space is exhausted"; | | "LSD label space is exhausted"; |
| } | | } |
| leaf label-oor-version { | | leaf label-oor-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Label Version when OOR happens"; | | "Label Version when OOR happens"; |
| } | | } |
| leaf label-fail { | | leaf label-fail { |
| type boolean; | | type boolean; |
| description | | description |
| "LSD label allocation failed "; | | "LSD label allocation failed "; |
| } | | } |
| leaf route-distinguisher { | | leaf route-distinguisher { |
| type xr:Route-dist; | | type xr:Route-dist; |
| description | | description |
| n | "BGP path Route Distinguisher"; | n | "Route Distinguisher"; |
| } | | } |
| leaf source-route-distinguisher { | | leaf source-route-distinguisher { |
| type xr:Route-dist; | | type xr:Route-dist; |
| description | | description |
| n | "BGP path Source Route Distinguisher"; | n | "Source Route Distinguisher"; |
| } | | } |
| leaf original-source-route-distinguisher { | | leaf original-source-route-distinguisher { |
| type xr:Route-dist; | | type xr:Route-dist; |
| description | | description |
| n | "BGP path Original Source Route Distinguisher"; | n | "Original Source Route Distinguisher"; |
| } | | } |
| leaf prefix-version { | | leaf prefix-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Version of BGP Prefix Table"; | | "Version of BGP Prefix Table"; |
| } | | } |
| leaf vrf-name { | | leaf vrf-name { |
| type string; | | type string; |
| description | | description |
| "Name of the VRF"; | | "Name of the VRF"; |
| } | | } |
| leaf source-vrf-name { | | leaf source-vrf-name { |
| type string; | | type string; |
| description | | description |
| "Name of the source VRF"; | | "Name of the source VRF"; |
| } | | } |
| leaf srcaf-name { | | leaf srcaf-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Address family identifier"; | | "Address family identifier"; |
| n | } | n | |
| leaf sid-oor { | | |
| type boolean; | | |
| description | | |
| "SID out-of-resource state "; | | |
| } | | |
| leaf sid-oor-version { | | |
| type uint64; | | |
| description | | |
| "Sid Version when OOR happens"; | | |
| } | | |
| leaf sid-fail { | | |
| type boolean; | | |
| description | | |
| "SRv6 sid allocation failed "; | | |
| } | | |
| leaf attribute-index { | | |
| type uint64; | | |
| description | | |
| "Attribute index"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-NBR-PATH-INFO { | | |
| description | | |
| "Neighbor Path Info"; | | |
| leaf nbr-name { | | |
| type string; | | |
| description | | |
| "Neighbor Name"; | | |
| } | | |
| leaf numof-paths { | | |
| type uint32; | | |
| description | | |
| "Number of paths"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-ALL-NBR-PATH-INFO { | | |
| description | | |
| "List of BGP Neighbor and Paths Info"; | | |
| container processing-time { | | |
| description | | |
| "Time at which statistics were collected"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| leaf num-of-nbrs { | | |
| type uint32; | | |
| description | | |
| "Number of neighbors from which prefixes were | | |
| received in the last time frame"; | | |
| } | | |
| leaf num-of-paths { | | |
| type uint32; | | |
| description | | |
| "Number of paths received in last time frame"; | | |
| } | | |
| list nbr-path { | | |
| description | | |
| "List of neighbors with the highest number of | | |
| paths"; | | |
| uses BGP-NBR-PATH-INFO; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-ECMP-PREFIX-TUPLE { | | |
| description | | |
| "BGP ECMP and prefix tuple"; | | |
| leaf numof-ecmp { | | |
| type uint32; | | |
| description | | |
| "Number of ECMP paths"; | | |
| } | | |
| leaf prefixes-processed { | | |
| type uint32; | | |
| description | | |
| "Number of prefixes processed for given ecmp | | |
| paths"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-ECMP-PATH-INFO { | | |
| description | | |
| "BGP Prefix Stats"; | | |
| container processing-time { | | |
| description | | |
| "Time when prefixes were processed"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| list ecmp-prefix { | | |
| description | | |
| "List of number of prefixes processed for each | | |
| set of ecmp paths"; | | |
| uses BGP-ECMP-PREFIX-TUPLE; | | |
| } | | |
| } | | |
| | | |
| grouping PLATFORM-OOR-STATE { | | |
| description | | |
| "PLATFORM OOR STATE"; | | |
| container time-of-oor-state-change { | | |
| description | | |
| "Timestamp when state first encountered"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| leaf oor-state { | | |
| type uint32; | | |
| description | | |
| "OOR State color"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-DELAYED-BP-QUEUE { | | |
| description | | |
| "BGP DELAYED BP QUEUE"; | | |
| container expiry-time { | | |
| description | | |
| "Delayed best path queue expiry time"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| leaf queue-size { | | |
| type uint32; | | |
| description | | |
| "Number of nets in the delayed BP queue"; | | |
| } | | } |
| } | | } |
| | | |
| grouping BGP-PERF-PROCESS-AF-VRF { | | grouping BGP-PERF-PROCESS-AF-VRF { |
| description | | description |
| "BGP PERF PROCESS AF VRF"; | | "BGP PERF PROCESS AF VRF"; |
| container time-rib-coverged { | | container time-rib-coverged { |
| description | | description |
| "Time last RIB ack was sent "; | | "Time last RIB ack was sent "; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container time-rib-down { | | container time-rib-down { |
| description | | description |
| "Time last RIB down wassent. This field is | | "Time last RIB down wassent. This field is |
| deprecated"; | | deprecated"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container first-rib-table-full-timestamp { | | container first-rib-table-full-timestamp { |
| description | | description |
| "Timestamp when RIB table was full for the first | | "Timestamp when RIB table was full for the first |
| time"; | | time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-rib-table-full-timestamp { | | container last-rib-table-full-timestamp { |
| description | | description |
| "Timestamp when RIB table was full for the last | | "Timestamp when RIB table was full for the last |
| time"; | | time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container first-rib-table-has-space-timestamp { | | container first-rib-table-has-space-timestamp { |
| description | | description |
| "Timestamp when RIB table had space for the first | | "Timestamp when RIB table had space for the first |
| time"; | | time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-rib-table-has-space-timestamp { | | container last-rib-table-has-space-timestamp { |
| description | | description |
| "Timestamp when RIB table had space for the last | | "Timestamp when RIB table had space for the last |
| time"; | | time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container time-label-retain { | | container time-label-retain { |
| description | | description |
| "Time last label retentiontriggered "; | | "Time last label retentiontriggered "; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| n | container last-bpq-delayed { | n | |
| description | | |
| "Time when last BP queue was delayed"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container last-processed-bpq-delayed { | | |
| description | | |
| "Time when last delayed BP queue was processed"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container last-oor-recovery { | | |
| description | | |
| "Time at which last time BGP recovered from OOR"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| leaf update-generation-calls { | | leaf update-generation-calls { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of calls to update generation function"; | | "No. of calls to update generation function"; |
| } | | } |
| leaf update-generation-prefixes-count { | | leaf update-generation-prefixes-count { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of prefixes updates generated for"; | | "No. of prefixes updates generated for"; |
| } | | } |
| leaf update-generation-be-prefixes-count { | | leaf update-generation-be-prefixes-count { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of be prefixes updates generated for"; | | "No. of be prefixes updates generated for"; |
| } | | } |
| leaf update-generation-messages-count { | | leaf update-generation-messages-count { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of update messages generated"; | | "No. of update messages generated"; |
| } | | } |
| leaf update-generation-time { | | leaf update-generation-time { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Time spent generating updates (milliseconds)"; | | "Time spent generating updates (milliseconds)"; |
| } | | } |
| leaf rib-update-calls { | | leaf rib-update-calls { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of calls to RIB update function"; | | "No. of calls to RIB update function"; |
| } | | } |
| leaf rib-update-time { | | leaf rib-update-time { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Time spent sending RIB updates (milliseconds)"; | | "Time spent sending RIB updates (milliseconds)"; |
| } | | } |
| leaf prefixes-sent-to-rib { | | leaf prefixes-sent-to-rib { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of prefixes sent to RIB"; | | "No. of prefixes sent to RIB"; |
| } | | } |
| leaf prefixes-resent-to-rib { | | leaf prefixes-resent-to-rib { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of prefixes re-sent to RIB"; | | "No. of prefixes re-sent to RIB"; |
| } | | } |
| leaf prefixes-not-sent-to-rib { | | leaf prefixes-not-sent-to-rib { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of prefixes not sent to RIB due to | | "No. of prefixes not sent to RIB due to |
| unsupported label stack size"; | | unsupported label stack size"; |
| } | | } |
| leaf prefixes-removed-from-rib { | | leaf prefixes-removed-from-rib { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of prefixes withdrawn from RIB"; | | "No. of prefixes withdrawn from RIB"; |
| } | | } |
| leaf attributes-sent-to-rib { | | leaf attributes-sent-to-rib { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of attributes sent to RIB"; | | "No. of attributes sent to RIB"; |
| } | | } |
| leaf attributes-removed-from-rib { | | leaf attributes-removed-from-rib { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of attributes withdrawn from RIB"; | | "No. of attributes withdrawn from RIB"; |
| } | | } |
| leaf attributes-recover-from-rib { | | leaf attributes-recover-from-rib { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of attributes recovered from RIB"; | | "No. of attributes recovered from RIB"; |
| } | | } |
| leaf scanner-runs { | | leaf scanner-runs { |
| type uint32; | | type uint32; |
| description | | description |
| "# of times scanner has run"; | | "# of times scanner has run"; |
| } | | } |
| leaf scanner-time { | | leaf scanner-time { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Time spent running scanner (milliseconds)"; | | "Time spent running scanner (milliseconds)"; |
| } | | } |
| leaf rib-tbl-del-calls { | | leaf rib-tbl-del-calls { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of rib update skipped on account of table | | "No. of rib update skipped on account of table |
| delete"; | | delete"; |
| } | | } |
| leaf rib-tbl-invalid-calls { | | leaf rib-tbl-invalid-calls { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of rib update skipped due to table invalid"; | | "No. of rib update skipped due to table invalid"; |
| } | | } |
| leaf rib-tbl-skip-calls { | | leaf rib-tbl-skip-calls { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of rib update skipped"; | | "No. of rib update skipped"; |
| } | | } |
| leaf rib-tbl-local-label { | | leaf rib-tbl-local-label { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of rib update skipped. due to no local label"; | | "No. of rib update skipped. due to no local label"; |
| } | | } |
| leaf rib-tbl-retry { | | leaf rib-tbl-retry { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of table rib retires."; | | "No. of table rib retires."; |
| } | | } |
| leaf time-last-update-sent { | | leaf time-last-update-sent { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time last update was sent (seconds since Jan 1 | | "Time last update was sent (seconds since Jan 1 |
| 1970)"; | | 1970)"; |
| } | | } |
| leaf is-rib-table-full { | | leaf is-rib-table-full { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates if RIB table is in prefix-limit state"; | | "Indicates if RIB table is in prefix-limit state"; |
| } | | } |
| leaf rib-table-full-version { | | leaf rib-table-full-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Version when RIB table became full (from | | "Version when RIB table became full (from |
| non-full)"; | | non-full)"; |
| } | | } |
| leaf first-rib-table-full-version { | | leaf first-rib-table-full-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Version when RIB table was full for the first | | "Version when RIB table was full for the first |
| time"; | | time"; |
| } | | } |
| leaf last-rib-table-full-version { | | leaf last-rib-table-full-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Version when RIB table was full for the last | | "Version when RIB table was full for the last |
| time"; | | time"; |
| } | | } |
| leaf last-rib-table-full-age { | | leaf last-rib-table-full-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since RIB table was full for the last time | | "Time since RIB table was full for the last time |
| (in seconds)"; | | (in seconds)"; |
| } | | } |
| leaf first-rib-table-has-space-version { | | leaf first-rib-table-has-space-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Version when RIB table had space for the first | | "Version when RIB table had space for the first |
| time"; | | time"; |
| } | | } |
| leaf last-rib-table-has-space-version { | | leaf last-rib-table-has-space-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Version when RIB table had space for the last | | "Version when RIB table had space for the last |
| time"; | | time"; |
| } | | } |
| leaf last-rib-table-has-space-age { | | leaf last-rib-table-has-space-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Times since RIB table had space for the last | | "Times since RIB table had space for the last |
| time (in seconds)"; | | time (in seconds)"; |
| } | | } |
| leaf rib-trigger { | | leaf rib-trigger { |
| type boolean; | | type boolean; |
| description | | description |
| "Rib trigger enabled"; | | "Rib trigger enabled"; |
| } | | } |
| leaf vrf-flags { | | leaf vrf-flags { |
| type uint32; | | type uint32; |
| description | | description |
| "VRF flags for debug display"; | | "VRF flags for debug display"; |
| } | | } |
| leaf label-calls { | | leaf label-calls { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of calls to label allocation processing | | "No. of calls to label allocation processing |
| function"; | | function"; |
| } | | } |
| leaf label-time { | | leaf label-time { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Time spent running label processing | | "Time spent running label processing |
| (milliseconds)"; | | (milliseconds)"; |
| } | | } |
| leaf label-rewrite-count { | | leaf label-rewrite-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of label rewrites created"; | | "Number of label rewrites created"; |
| } | | } |
| leaf label-release-count { | | leaf label-release-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of labels released"; | | "Number of labels released"; |
| } | | } |
| leaf label-added-count { | | leaf label-added-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of labels requested"; | | "Number of labels requested"; |
| } | | } |
| leaf import-calls { | | leaf import-calls { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of calls to import processing function"; | | "Number of calls to import processing function"; |
| } | | } |
| leaf import-time { | | leaf import-time { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| "Time spent in import processing (milliseconds) | | "Time spent in import processing (milliseconds) |
| Note time accounted against source nets."; | | Note time accounted against source nets."; |
| } | | } |
| leaf import-src-net-processed-count { | | leaf import-src-net-processed-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of source nets processed"; | | "Number of source nets processed"; |
| } | | } |
| leaf import-dest-net-processed-count { | | leaf import-dest-net-processed-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of destination nets processed"; | | "Number of destination nets processed"; |
| } | | } |
| leaf import-added-path-count { | | leaf import-added-path-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of imported paths added"; | | "Number of imported paths added"; |
| } | | } |
| leaf import-removed-path-count { | | leaf import-removed-path-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of imported paths removed"; | | "Number of imported paths removed"; |
| } | | } |
| leaf import-replaced-path-count { | | leaf import-replaced-path-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of imported paths "; | | "Number of imported paths "; |
| } | | } |
| leaf update-group-count { | | leaf update-group-count { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of update group"; | | "No. of update group"; |
| } | | } |
| leaf subgroup-count { | | leaf subgroup-count { |
| type uint32; | | type uint32; |
| description | | description |
| "No. of update subgroup"; | | "No. of update subgroup"; |
| } | | } |
| n | leaf oldest-queue-number { | n | |
| type uint32; | | |
| description | | |
| "Earliest queue number to be processed for | | |
| delayed BP"; | | |
| } | | |
| leaf recent-queue-number { | | |
| type uint32; | | |
| description | | |
| "Most recent queue number for delayed BP"; | | |
| } | | |
| leaf prefix-count-hwm { | | |
| type uint32; | | |
| description | | |
| "Delayed BP Prefix High water mark"; | | |
| } | | |
| leaf net-delayed-count { | | |
| type uint32; | | |
| description | | |
| "Number of times nets delayed"; | | |
| } | | |
| leaf path-delayed-count { | | |
| type uint32; | | |
| description | | |
| "Number of paths delayed"; | | |
| } | | |
| leaf net-processed-count { | | |
| type uint32; | | |
| description | | |
| "Number of nets dequeued and processed"; | | |
| } | | |
| list delayed-bp-queue { | | |
| description | | |
| "List of queues used for delayed BP"; | | |
| uses BGP-DELAYED-BP-QUEUE; | | |
| } | | |
| list oor-state { | | |
| description | | |
| "Upto Last 5 OOR state change info"; | | |
| uses PLATFORM-OOR-STATE; | | |
| } | | |
| list ribecmp-path-download-info { | | |
| description | | |
| "List of ecmp paths downloaded to RIB"; | | |
| uses BGP-ECMP-PATH-INFO; | | |
| } | | |
| list delay-queue-ecmp-path-info { | | |
| description | | |
| "List of ecmp paths processed in delay queue"; | | |
| uses BGP-ECMP-PATH-INFO; | | |
| } | | |
| list nbr-path-stat { | | |
| description | | |
| "List of neighbor vs paths info"; | | |
| uses BGP-ALL-NBR-PATH-INFO; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-INT-BUMPCOUNT { | | |
| description | | |
| "BGP INT BUMPCOUNT"; | | |
| leaf bump-count-event { | | |
| type Bgp-vr-bumpcount-event; | | |
| description | | |
| "Event contributing to version bumps"; | | |
| } | | |
| leaf version-bump-count { | | |
| type uint32; | | |
| description | | |
| "Rolling average of version bumps in this stat | | |
| collection interval"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-VER-RATE { | | |
| description | | |
| "BGP VER RATE"; | | |
| container version-bump-count-interval-start { | | |
| description | | |
| "Start time of the stat collection interval"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container version-bump-count-interval-end { | | |
| description | | |
| "End time of the stat collection interval"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| leaf interval-info { | | |
| type Bgp-vr-int; | | |
| description | | |
| "Stat collection interval identifier"; | | |
| } | | |
| leaf main-table-version-bump-count { | | |
| type uint32; | | |
| description | | |
| "Rolling average of main table version bumps in | | |
| this stat collection interval"; | | |
| } | | |
| list version-bump-count-interval { | | |
| description | | |
| "Version bumps per event in the stat collection | | |
| interval"; | | |
| uses BGP-INT-BUMPCOUNT; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-TOTAL-BUMPS { | | |
| description | | |
| "BGP TOTAL BUMPS"; | | |
| leaf bump-event-count { | | |
| type Bgp-vr-bumpcount-event; | | |
| description | | |
| "Event contributing to version bumps"; | | |
| } | | |
| leaf version-bumps-count { | | |
| type uint64; | | |
| description | | |
| "Total number of version bumps"; | | |
| } | | |
| } | | } |
| | | |
| grouping BGP-PERF-PROCESS-AF-GBL { | | grouping BGP-PERF-PROCESS-AF-GBL { |
| description | | description |
| "BGP PERF PROCESS AF GBL"; | | "BGP PERF PROCESS AF GBL"; |
| leaf has-converged { | | leaf has-converged { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if process has converged"; | | "TRUE if process has converged"; |
| } | | } |
| leaf first-nbr-up-time { | | leaf first-nbr-up-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time when first peer came up (seconds since Jan | | "Time when first peer came up (seconds since Jan |
| 1 1970)"; | | 1 1970)"; |
| } | | } |
| leaf total-pim-install { | | leaf total-pim-install { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of install to PIM"; | | "Total number of install to PIM"; |
| } | | } |
| leaf total-pim-callbacks { | | leaf total-pim-callbacks { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of PIM callbacks"; | | "Total number of PIM callbacks"; |
| } | | } |
| leaf total-pim-callback-batch { | | leaf total-pim-callback-batch { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of Pim callback batches"; | | "Total number of Pim callback batches"; |
| n | } | n | |
| leaf update-main-table-version { | | |
| type uint64; | | |
| description | | |
| "Main table version"; | | |
| } | | } |
| list mode-enter-time { | | list mode-enter-time { |
| max-elements "7"; | | max-elements "7"; |
| description | | description |
| "Time that each mode was entered (seconds since | | "Time that each mode was entered (seconds since |
| | | |
| Jan 1 1970)"; | | Jan 1 1970)"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time that each mode was entered (seconds since | | "Time that each mode was entered (seconds since |
| | | |
| Jan 1 1970)"; | | Jan 1 1970)"; |
| } | | } |
| } | | } |
| list total-pim-install-add { | | list total-pim-install-add { |
| max-elements "7"; | | max-elements "7"; |
| description | | description |
| "Total number of install to PIM for add"; | | "Total number of install to PIM for add"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of install to PIM for add"; | | "Total number of install to PIM for add"; |
| } | | } |
| } | | } |
| list total-pim-install-del { | | list total-pim-install-del { |
| max-elements "7"; | | max-elements "7"; |
| description | | description |
| "Total number of install to PIM for del"; | | "Total number of install to PIM for del"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of install to PIM for del"; | | "Total number of install to PIM for del"; |
| } | | } |
| } | | } |
| list total-pim-callback-add { | | list total-pim-callback-add { |
| max-elements "7"; | | max-elements "7"; |
| description | | description |
| "Total number of Pim callbacks for add"; | | "Total number of Pim callbacks for add"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of Pim callbacks for add"; | | "Total number of Pim callbacks for add"; |
| } | | } |
| } | | } |
| list total-pim-callback-del { | | list total-pim-callback-del { |
| max-elements "7"; | | max-elements "7"; |
| description | | description |
| "Total number of Pim callbacks for del"; | | "Total number of Pim callbacks for del"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of Pim callbacks for del"; | | "Total number of Pim callbacks for del"; |
| } | | } |
| } | | } |
| list total-pim-callback-add-local { | | list total-pim-callback-add-local { |
| max-elements "7"; | | max-elements "7"; |
| description | | description |
| "Total number of Pim callbacks for local add"; | | "Total number of Pim callbacks for local add"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of Pim callbacks for local add"; | | "Total number of Pim callbacks for local add"; |
| } | | } |
| } | | } |
| list total-pim-callback-del-local { | | list total-pim-callback-del-local { |
| max-elements "7"; | | max-elements "7"; |
| description | | description |
| "Total number of Pim callbacks for Local del"; | | "Total number of Pim callbacks for Local del"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Total number of Pim callbacks for Local del"; | | "Total number of Pim callbacks for Local del"; |
| } | | } |
| } | | } |
| n | list total-version-bump-count { | n | |
| description | | |
| "Total version bumps per event"; | | |
| uses BGP-TOTAL-BUMPS; | | |
| } | | |
| list version-rate-stat { | | |
| max-elements "4"; | | |
| description | | |
| "Version bump stats per event per interval"; | | |
| uses BGP-VER-RATE; | | |
| } | | |
| } | | } |
| | | |
| grouping BGP-PERF-PROCESS-AF { | | grouping BGP-PERF-PROCESS-AF { |
| description | | description |
| "BGP PERF PROCESS AF"; | | "BGP PERF PROCESS AF"; |
| container global { | | container global { |
| description | | description |
| "Global information"; | | "Global information"; |
| uses BGP-PERF-PROCESS-AF-GBL; | | uses BGP-PERF-PROCESS-AF-GBL; |
| } | | } |
| container vrf { | | container vrf { |
| description | | description |
| "VRF information"; | | "VRF information"; |
| uses BGP-PERF-PROCESS-AF-VRF; | | uses BGP-PERF-PROCESS-AF-VRF; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-PROCESS-INFO-AF-VRF { | | grouping BGP-PROCESS-INFO-AF-VRF { |
| description | | description |
| "BGP PROCESS INFO AF VRF"; | | "BGP PROCESS INFO AF VRF"; |
| leaf network-entry-count { | | leaf network-entry-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of network entries"; | | "Number of network entries"; |
| } | | } |
| leaf paths-count { | | leaf paths-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of paths"; | | "Number of paths"; |
| } | | } |
| leaf imported-paths { | | leaf imported-paths { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of imported paths"; | | "Number of imported paths"; |
| } | | } |
| leaf local-paths { | | leaf local-paths { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of local paths"; | | "Number of local paths"; |
| } | | } |
| leaf path-elems-count { | | leaf path-elems-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of path elems"; | | "Number of path elems"; |
| } | | } |
| leaf path-memory { | | leaf path-memory { |
| n | type uint64; | n | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| n | "Memory (in bytes) used by path data | n | "Memory (in bytes) used by path data"; |
| (Approximate)"; | | |
| } | | } |
| leaf imported-path-memory { | | leaf imported-path-memory { |
| n | type uint64; | n | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| n | "Memory (in bytes) used by imported paths | n | "Memory (in bytes) used by imported paths"; |
| (Approximate)"; | | |
| } | | } |
| leaf local-path-memory { | | leaf local-path-memory { |
| n | type uint64; | n | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| n | "Memory (in bytes) used by local paths | n | "Memory (in bytes) used by local paths"; |
| (Approximate)"; | | |
| } | | } |
| leaf prefix-memory { | | leaf prefix-memory { |
| n | type uint64; | n | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| n | "Memory (in bytes) used by prefix data | n | "Memory (in bytes) used by prefix data"; |
| (Approximate)"; | | |
| } | | } |
| leaf path-elem-memory { | | leaf path-elem-memory { |
| n | type uint64; | n | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| n | "Memory (in bytes) used by pathelem data | n | "Memory (in bytes) used by pathelem data"; |
| (Approximate)"; | | |
| } | | } |
| leaf received-path-count { | | leaf received-path-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of (unused) received paths for inbound | | "Number of (unused) received paths for inbound |
| soft reconfiguration"; | | soft reconfiguration"; |
| } | | } |
| leaf history-path-count { | | leaf history-path-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of history paths (for dampening)"; | | "Number of history paths (for dampening)"; |
| } | | } |
| leaf damped-path-count { | | leaf damped-path-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of dampened paths"; | | "Number of dampened paths"; |
| } | | } |
| leaf malloced-prefix-count { | | leaf malloced-prefix-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Activity: Number of prefixes malloced"; | | "Activity: Number of prefixes malloced"; |
| } | | } |
| leaf freed-prefix-count { | | leaf freed-prefix-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Activity: Number of prefixes freed"; | | "Activity: Number of prefixes freed"; |
| } | | } |
| leaf malloced-path-count { | | leaf malloced-path-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Activity: Number of paths malloced"; | | "Activity: Number of paths malloced"; |
| } | | } |
| leaf freed-path-count { | | leaf freed-path-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Activity: Number of paths freed"; | | "Activity: Number of paths freed"; |
| } | | } |
| leaf malloced-path-elem-count { | | leaf malloced-path-elem-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Activity: Number of path elems malloced"; | | "Activity: Number of path elems malloced"; |
| } | | } |
| leaf freed-path-elem-count { | | leaf freed-path-elem-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Activity: Number of pathelems freed"; | | "Activity: Number of pathelems freed"; |
| } | | } |
| leaf any-ebgp-neighbor-missing-policy { | | leaf any-ebgp-neighbor-missing-policy { |
| type boolean; | | type boolean; |
| description | | description |
| "Is there any neighbor which is missing either | | "Is there any neighbor which is missing either |
| inbound or outbound or both routing policy for | | inbound or outbound or both routing policy for |
| this address family?"; | | this address family?"; |
| } | | } |
| leaf attribute-download { | | leaf attribute-download { |
| type boolean; | | type boolean; |
| description | | description |
| n | "BGP virtual routing and forwarding attribute | n | |
| download "; | | "Attribute download is "; |
| } | | } |
| leaf route-target-download { | | leaf route-target-download { |
| type boolean; | | type boolean; |
| description | | description |
| "Route Target download is enabled"; | | "Route Target download is enabled"; |
| } | | } |
| leaf srms-prefix-sid { | | leaf srms-prefix-sid { |
| type boolean; | | type boolean; |
| description | | description |
| "SRMS Prefix SID is "; | | "SRMS Prefix SID is "; |
| } | | } |
| leaf add-path-install-enable { | | leaf add-path-install-enable { |
| type boolean; | | type boolean; |
| description | | description |
| "Additional paths installation is enabled"; | | "Additional paths installation is enabled"; |
| } | | } |
| leaf add-path-install-disable { | | leaf add-path-install-disable { |
| type boolean; | | type boolean; |
| description | | description |
| "Additional paths installation is disabled"; | | "Additional paths installation is disabled"; |
| } | | } |
| leaf best-external { | | leaf best-external { |
| type boolean; | | type boolean; |
| description | | description |
| "Best External is enabled"; | | "Best External is enabled"; |
| } | | } |
| leaf best-external-disable { | | leaf best-external-disable { |
| type boolean; | | type boolean; |
| description | | description |
| "Best External is enabled"; | | "Best External is enabled"; |
| n | } | n | |
| leaf best-external-labeled-unicast { | | |
| type boolean; | | |
| description | | |
| "Best External is limited toLabeled-Unicast"; | | |
| } | | } |
| leaf label-retain { | | leaf label-retain { |
| type boolean; | | type boolean; |
| description | | description |
| "Label retention is enabled"; | | "Label retention is enabled"; |
| } | | } |
| leaf label-retainvalue { | | leaf label-retainvalue { |
| type uint32; | | type uint32; |
| description | | description |
| "Label retention value enabled"; | | "Label retention value enabled"; |
| } | | } |
| leaf tbl-bitf-size { | | leaf tbl-bitf-size { |
| type uint16; | | type uint16; |
| description | | description |
| "Bitfield size on table"; | | "Bitfield size on table"; |
| } | | } |
| leaf tbl-chunk-bitf-size { | | leaf tbl-chunk-bitf-size { |
| type uint16; | | type uint16; |
| description | | description |
| "Chunk Bitfield size on table"; | | "Chunk Bitfield size on table"; |
| } | | } |
| n | leaf tbl-filter-group-bitf-resize-pending { | n | |
| type boolean; | | |
| description | | |
| "Filter Group bitfield resize is pending for this | | |
| table"; | | |
| } | | |
| leaf is-route-reflector { | | leaf is-route-reflector { |
| type boolean; | | type boolean; |
| description | | description |
| "Router is an RR for this AF"; | | "Router is an RR for this AF"; |
| } | | } |
| leaf asbr { | | leaf asbr { |
| type boolean; | | type boolean; |
| description | | description |
| "Router is an ASBR for this AF"; | | "Router is an ASBR for this AF"; |
| } | | } |
| leaf retain-rt-all { | | leaf retain-rt-all { |
| type boolean; | | type boolean; |
| description | | description |
| "Retain-RT-All enabled"; | | "Retain-RT-All enabled"; |
| } | | } |
| leaf ibgp-nexthop-self-count { | | leaf ibgp-nexthop-self-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of iBGP sessions configured with nh-self"; | | "Number of iBGP sessions configured with nh-self"; |
| } | | } |
| leaf use-igpsr-label { | | leaf use-igpsr-label { |
| type boolean; | | type boolean; |
| description | | description |
| "Use IGP SR label for resolution"; | | "Use IGP SR label for resolution"; |
| } | | } |
| leaf bmp-network-entry-count { | | leaf bmp-network-entry-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of BMP net entries"; | | "Number of BMP net entries"; |
| } | | } |
| leaf bmp-paths-count { | | leaf bmp-paths-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Total Number of BMP paths"; | | "Total Number of BMP paths"; |
| } | | } |
| leaf bmp-prefix-memory { | | leaf bmp-prefix-memory { |
| n | type uint64; | n | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| n | "Memory (in bytes) used by prefix data | n | "Memory (in bytes) used by prefix data"; |
| (Approximate)"; | | |
| } | | } |
| leaf bmp-path-memory { | | leaf bmp-path-memory { |
| n | type uint64; | n | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| n | "Memory (in bytes) used by path data | n | "Memory (in bytes) used by path data"; |
| (Approximate)"; | | |
| } | | |
| leaf path-lookup-path-count { | | |
| type uint32; | | |
| description | | |
| "Number of paths in path lookup db"; | | |
| } | | |
| leaf path-denied-count { | | |
| type uint32; | | |
| description | | |
| "Total Number of paths denied"; | | |
| } | | |
| leaf path-accepted-count { | | |
| type uint32; | | |
| description | | |
| "Total Number of paths accepted"; | | |
| } | | |
| leaf path-modified-count { | | |
| type uint32; | | |
| description | | |
| "Total Number of paths modified"; | | |
| } | | |
| leaf path-modified-count-hwm { | | |
| type uint32; | | |
| description | | |
| "Total Number of paths modified for the given AFI | | |
| High Water Mark"; | | |
| } | | |
| leaf path-modified-memory-hwm { | | |
| type uint64; | | |
| description | | |
| "Total memory allocated for modified paths High | | |
| Water Mark (Approximate)"; | | |
| } | | |
| leaf path-modified-count-hwm-time { | | |
| type uint64; | | |
| description | | |
| "Timestamp for High Water Mark of total paths | | |
| modified for the given AFI"; | | |
| } | | |
| leaf path-modified-memory { | | |
| type uint64; | | |
| description | | |
| "Total memory allocated for pathmodified paths in | | |
| BGP process (Approximate)"; | | |
| } | | |
| leaf policy-has-nexthop-self { | | |
| type boolean; | | |
| description | | |
| "Policy has next-hop self"; | | |
| } | | |
| list net-path-distribution { | | |
| description | | |
| "Net Paths Distribution"; | | |
| leaf entry { | | |
| type uint32; | | |
| description | | |
| "Net Paths Distribution"; | | |
| } | | |
| } | | } |
| } | | } |
| | | |
| grouping BGP-RIB-INSTALL-TIME-INFO { | | grouping BGP-RIB-INSTALL-TIME-INFO { |
| description | | description |
| "BGP RIB INSTALL TIME INFO"; | | "BGP RIB INSTALL TIME INFO"; |
| container update-time { | | container update-time { |
| description | | description |
| n | "The time taken for routing information base | n | "RIB update time"; |
| download "; | | |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container install-time { | | container install-time { |
| description | | description |
| n | "The time taken for the route installation "; | n | "RIB install time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| leaf installed-count { | | leaf installed-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Count of installed routes"; | n | "Installed routes"; |
| } | | } |
| leaf modified-count { | | leaf modified-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Count of modified routes"; | n | "Modified routes"; |
| } | | } |
| leaf skipped-count { | | leaf skipped-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Count of skipped routes"; | n | "Skipped routes"; |
| } | | } |
| leaf withdrawn-count { | | leaf withdrawn-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Count of withdrawn routes"; | n | "Withdrawn routes"; |
| } | | } |
| leaf start-version { | | leaf start-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| n | "Start version of the BGP routing information | n | "Start version"; |
| base "; | | |
| } | | } |
| leaf target-version { | | leaf target-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| n | "Target version of BGProuting information | n | "Target version"; |
| baseupdate "; | | |
| } | | } |
| } | | } |
| | | |
| grouping BGP-THREAD-TRIGGER-INFO-STAT { | | grouping BGP-THREAD-TRIGGER-INFO-STAT { |
| description | | description |
| "BGP THREAD TRIGGER INFO STAT"; | | "BGP THREAD TRIGGER INFO STAT"; |
| container trigger-time-spec { | | container trigger-time-spec { |
| description | | description |
| n | "Timestamp when the thread was triggered "; | n | "trigger time spec"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| leaf trigger-version { | | leaf trigger-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| n | "The thread version last timethe thread is run"; | n | "TriggerVersion"; |
| } | | } |
| leaf trigger-table-version { | | leaf trigger-table-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "TriggerTableVersion"; | | "TriggerTableVersion"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-THREAD-TRIGGER-INFO { | | grouping BGP-THREAD-TRIGGER-INFO { |
| description | | description |
| "BGP THREAD TRIGGER INFO"; | | "BGP THREAD TRIGGER INFO"; |
| leaf triggers { | | leaf triggers { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of times the threadwas triggered"; | n | "Triggers"; |
| } | | } |
| list statistic { | | list statistic { |
| description | | description |
| n | "stats recorded per trigger"; | n | "statistic"; |
| uses BGP-THREAD-TRIGGER-INFO-STAT; | | uses BGP-THREAD-TRIGGER-INFO-STAT; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-PROCESS-INFO-AF-GBL { | | grouping BGP-PROCESS-INFO-AF-GBL { |
| description | | description |
| "BGP PROCESS INFO AF GBL"; | | "BGP PROCESS INFO AF GBL"; |
| n | | n | container version-wrap-time-spec { |
| | | description |
| | | "Version Wrap timestamp"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container version-wrap-start-time-spec { |
| | | description |
| | | "Version Wrap handle start timestamp"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| | | container version-wrap-done-time-spec { |
| | | description |
| | | "Version Wrap handle Done timestamp"; |
| | | uses BGP-TIMESPEC; |
| | | } |
| container trigger-rib { | | container trigger-rib { |
| description | | description |
| "Trigger RIB"; | | "Trigger RIB"; |
| uses BGP-THREAD-TRIGGER-INFO; | | uses BGP-THREAD-TRIGGER-INFO; |
| } | | } |
| container trigger-import { | | container trigger-import { |
| description | | description |
| n | "Flag to keep track of import triggers to each of | n | "Trigger import"; |
| the threads"; | | |
| uses BGP-THREAD-TRIGGER-INFO; | | uses BGP-THREAD-TRIGGER-INFO; |
| } | | } |
| container trigger-update { | | container trigger-update { |
| description | | description |
| n | "Flag to keep track of update triggers for each | n | "Trigger update"; |
| thread"; | | |
| uses BGP-THREAD-TRIGGER-INFO; | | uses BGP-THREAD-TRIGGER-INFO; |
| } | | } |
| container trigger-label { | | container trigger-label { |
| description | | description |
| n | "Label to keep track of trigger for each thread"; | n | "Trigger label"; |
| uses BGP-THREAD-TRIGGER-INFO; | | uses BGP-THREAD-TRIGGER-INFO; |
| } | | } |
| container rib-install { | | container rib-install { |
| description | | description |
| "RIB install info"; | | "RIB install info"; |
| uses BGP-RIB-INSTALL-TIME-INFO; | | uses BGP-RIB-INSTALL-TIME-INFO; |
| } | | } |
| leaf router-state { | | leaf router-state { |
| type Bgp-rtr-state; | | type Bgp-rtr-state; |
| description | | description |
| n | "BGP router state for the address family "; | n | "Router state"; |
| } | | } |
| leaf table-version { | | leaf table-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| n | "BGP main routing table version"; | n | "BGP table version"; |
| | | } |
| | | leaf version-wrapped { |
| | | type uint32; |
| | | description |
| | | "Number of times Version Wrap happened"; |
| | | } |
| | | leaf version-wrapped-tid { |
| | | type uint32; |
| | | description |
| | | "Version Wrapped trigger tid"; |
| } | | } |
| leaf max-active-pelem-version { | | leaf max-active-pelem-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Maximum Active Pelem Version"; | | "Maximum Active Pelem Version"; |
| } | | } |
| leaf merged-table-version { | | leaf merged-table-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| n | "The merged Bgp table version after RPFO"; | n | "Merged Table Version"; |
| } | | } |
| leaf route-download-go-active-done-pending { | | leaf route-download-go-active-done-pending { |
| type uint32; | | type uint32; |
| description | | description |
| n | "To indicate whether routedownload go-active-done | n | "Route Download Go Active Done Pending"; |
| pulse is sent or not"; | | |
| } | | } |
| leaf rib-brib-received-version { | | leaf rib-brib-received-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Version received from "; | | "Version received from "; |
| } | | } |
| leaf table-brib-version { | | leaf table-brib-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Version sent to RIB/bRIB"; | | "Version sent to RIB/bRIB"; |
| } | | } |
| leaf label-version { | | leaf label-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Version updated by label thread"; | | "Version updated by label thread"; |
| } | | } |
| leaf import-version { | | leaf import-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Version updated by import thread"; | | "Version updated by import thread"; |
| } | | } |
| leaf standby-version { | | leaf standby-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Version updated by sync thread"; | | "Version updated by sync thread"; |
| } | | } |
| leaf send-version { | | leaf send-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Version for sending updates to peers"; | | "Version for sending updates to peers"; |
| } | | } |
| leaf num-init-sync-pfx { | | leaf num-init-sync-pfx { |
| type uint32; | | type uint32; |
| description | | description |
| "Num of prefix synced during Initsync"; | | "Num of prefix synced during Initsync"; |
| } | | } |
| leaf max-label-stack-depth-v4-next-hop { | | leaf max-label-stack-depth-v4-next-hop { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Max supported label stack depth for IPv4 | n | "Max supported label stack depth for IPv4 Nexthop"; |
| Nexthop"; | | |
| } | | } |
| leaf max-label-stack-depth-v6-next-hop { | | leaf max-label-stack-depth-v6-next-hop { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Max supported label stack depth for IPv6 | n | "Max supported label stack depth for IPv6 Nexthop"; |
| Nexthop"; | | |
| } | | } |
| leaf local-networks-num { | | leaf local-networks-num { |
| type uint32; | | type uint32; |
| description | | description |
| "Total local networks"; | | "Total local networks"; |
| } | | } |
| leaf local-networks-memory { | | leaf local-networks-memory { |
| n | type uint64; | n | type uint32; |
| description | | description |
| n | "Total number of networks memory in global BGP | n | "Total local networks memory"; |
| address-family (Approximate)"; | | |
| } | | } |
| leaf local-networks-malloced-num { | | leaf local-networks-malloced-num { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Total number of networks for which memory is | n | "Total local networks malloced"; |
| allocated"; | | |
| } | | } |
| leaf local-networks-freed-num { | | leaf local-networks-freed-num { |
| type uint32; | | type uint32; |
| description | | description |
| "Total local networks freed"; | | "Total local networks freed"; |
| } | | } |
| leaf local-paths-num { | | leaf local-paths-num { |
| type uint32; | | type uint32; |
| description | | description |
| "Total local paths"; | | "Total local paths"; |
| } | | } |
| leaf local-paths-memory { | | leaf local-paths-memory { |
| n | type uint64; | n | type uint32; |
| description | | description |
| n | "Total memory allocated for local paths in BGP | n | "Total local paths memory"; |
| process (Approximate)"; | | |
| } | | } |
| leaf local-paths-malloced-num { | | leaf local-paths-malloced-num { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Total local paths for which memory allocated"; | n | "Total local paths malloced"; |
| } | | } |
| leaf local-paths-freed-num { | | leaf local-paths-freed-num { |
| type uint32; | | type uint32; |
| description | | description |
| "Total local paths freed"; | | "Total local paths freed"; |
| } | | } |
| leaf imported-paths-num { | | leaf imported-paths-num { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Total imported paths"; | n | "Total impoorted paths "; |
| } | | } |
| leaf imported-paths-memory { | | leaf imported-paths-memory { |
| n | type uint64; | n | type uint32; |
| description | | description |
| n | "Total memory allocated for imported paths in BGP | n | "Total imported paths memory"; |
| process (Approximate)"; | | |
| } | | } |
| leaf networks-num { | | leaf networks-num { |
| type uint32; | | type uint32; |
| description | | description |
| "Total Num of networks"; | | "Total Num of networks"; |
| } | | } |
| leaf networks-memory { | | leaf networks-memory { |
| n | type uint64; | n | type uint32; |
| description | | description |
| n | "Total memory allocated for networks in BGP | n | "Total networks memory"; |
| process (Approximate)"; | | |
| } | | } |
| leaf networks-malloced-num { | | leaf networks-malloced-num { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Total networks for which memory allocated"; | n | "Total networks malloced"; |
| } | | } |
| leaf networks-freed-num { | | leaf networks-freed-num { |
| type uint32; | | type uint32; |
| description | | description |
| "Total networks freed"; | | "Total networks freed"; |
| } | | } |
| leaf paths-num { | | leaf paths-num { |
| type uint32; | | type uint32; |
| description | | description |
| "Total Num of paths"; | | "Total Num of paths"; |
| } | | } |
| leaf paths-memory { | | leaf paths-memory { |
| n | type uint64; | n | type uint32; |
| description | | description |
| n | "Total paths memory (Approximate)"; | n | "Total paths memory"; |
| } | | } |
| leaf paths-malloced-num { | | leaf paths-malloced-num { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Total paths for which memory allocated"; | n | "Total paths malloced"; |
| } | | } |
| leaf paths-freed-num { | | leaf paths-freed-num { |
| type uint32; | | type uint32; |
| description | | description |
| "Total paths freed"; | | "Total paths freed"; |
| } | | } |
| leaf path-elems-num { | | leaf path-elems-num { |
| type uint32; | | type uint32; |
| description | | description |
| "Total Num of path-elems"; | | "Total Num of path-elems"; |
| } | | } |
| leaf path-elems-memory { | | leaf path-elems-memory { |
| n | type uint64; | n | type uint32; |
| description | | description |
| n | "Total memory allocated for path-elements in BGP | n | "Total path-elems memory"; |
| process (Approximate)"; | | |
| } | | } |
| leaf path-elems-malloced-num { | | leaf path-elems-malloced-num { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Total memory allocated for path-element number"; | n | "Total path-elems malloced"; |
| } | | } |
| leaf path-elems-freed-num { | | leaf path-elems-freed-num { |
| type uint32; | | type uint32; |
| description | | description |
| "Total path-elems freed"; | | "Total path-elems freed"; |
| } | | } |
| leaf label-last-trigger { | | leaf label-last-trigger { |
| type uint64; | | type uint64; |
| description | | description |
| "Timestamp when Label thread is last triggered"; | | "Timestamp when Label thread is last triggered"; |
| } | | } |
| leaf last-label-version { | | leaf last-label-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Label thread version when last triggered"; | | "Label thread version when last triggered"; |
| } | | } |
| leaf label-bgp-version { | | leaf label-bgp-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "BGP version when label thread is last triggered"; | | "BGP version when label thread is last triggered"; |
| } | | } |
| leaf label-triggers { | | leaf label-triggers { |
| type uint32; | | type uint32; |
| description | | description |
| "Label thread triggers"; | | "Label thread triggers"; |
| } | | } |
| leaf rib-last-trigger { | | leaf rib-last-trigger { |
| type uint64; | | type uint64; |
| description | | description |
| "Timestamp when RIB thread is last triggered"; | | "Timestamp when RIB thread is last triggered"; |
| } | | } |
| leaf last-rib-version { | | leaf last-rib-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "RIB thread version when last triggered"; | | "RIB thread version when last triggered"; |
| } | | } |
| leaf rib-bgp-version { | | leaf rib-bgp-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "BGP version when RIB thread is last triggered"; | | "BGP version when RIB thread is last triggered"; |
| } | | } |
| leaf rib-triggers { | | leaf rib-triggers { |
| type uint32; | | type uint32; |
| description | | description |
| "RIB thread triggers"; | | "RIB thread triggers"; |
| } | | } |
| leaf import-last-trigger { | | leaf import-last-trigger { |
| type uint64; | | type uint64; |
| description | | description |
| "Timestamp when Import thread is last triggered"; | | "Timestamp when Import thread is last triggered"; |
| } | | } |
| leaf last-import-version { | | leaf last-import-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Import thread version when last triggered"; | | "Import thread version when last triggered"; |
| } | | } |
| leaf import-bgp-version { | | leaf import-bgp-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "BGP version when Import thread is last triggered"; | | "BGP version when Import thread is last triggered"; |
| } | | } |
| leaf import-triggers { | | leaf import-triggers { |
| type uint32; | | type uint32; |
| description | | description |
| "Import thread triggers"; | | "Import thread triggers"; |
| } | | } |
| leaf update-gen-last-trigger { | | leaf update-gen-last-trigger { |
| type uint64; | | type uint64; |
| description | | description |
| "Timestamp when Update generation thread is last | | "Timestamp when Update generation thread is last |
| triggered"; | | triggered"; |
| } | | } |
| leaf update-gen-bgp-version { | | leaf update-gen-bgp-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "BGP version when Update generation thread is | | "BGP version when Update generation thread is |
| last triggered"; | | last triggered"; |
| } | | } |
| leaf update-triggers { | | leaf update-triggers { |
| type uint32; | | type uint32; |
| description | | description |
| "Update thread triggers"; | | "Update thread triggers"; |
| } | | } |
| leaf total-r-ds-num { | | leaf total-r-ds-num { |
| type uint32; | | type uint32; |
| description | | description |
| "Total Num of RDs"; | | "Total Num of RDs"; |
| } | | } |
| leaf total-remote-r-ds-num { | | leaf total-remote-r-ds-num { |
| type uint32; | | type uint32; |
| description | | description |
| "Total Num of remote RDs"; | | "Total Num of remote RDs"; |
| } | | } |
| leaf total-same-r-ds-num { | | leaf total-same-r-ds-num { |
| type uint32; | | type uint32; |
| description | | description |
| "Total Num of same RDs"; | | "Total Num of same RDs"; |
| } | | } |
| leaf malloced-rd-count { | | leaf malloced-rd-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Activity: Number of RDs malloced"; | | "Activity: Number of RDs malloced"; |
| } | | } |
| leaf freed-rd-count { | | leaf freed-rd-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Activity: Number of RDs freed"; | | "Activity: Number of RDs freed"; |
| } | | } |
| leaf rd-memory { | | leaf rd-memory { |
| n | type uint64; | n | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| n | "Memory (in bytes) used by RD data (Approximate)"; | n | "Memory (in bytes) used by RD data"; |
| } | | } |
| leaf multipath-network-entry-count { | | leaf multipath-network-entry-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of multipath network entries"; | | "Number of multipath network entries"; |
| } | | } |
| leaf multipath-network-entry-memory { | | leaf multipath-network-entry-memory { |
| n | type uint64; | n | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| "Memory (in bytes) used bymultipath network | | "Memory (in bytes) used bymultipath network |
| n | entries (Approximate)"; | n | entries"; |
| } | | } |
| leaf multipath-paths-count { | | leaf multipath-paths-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of multipath paths"; | | "Number of multipath paths"; |
| } | | } |
| leaf multipath-paths-memory { | | leaf multipath-paths-memory { |
| n | type uint64; | n | type uint32; |
| units "byte"; | | units "byte"; |
| description | | description |
| n | "Memory (in bytes) used bymultimpath paths | n | "Memory (in bytes) used bymultimpath paths"; |
| (Approximate)"; | | |
| } | | } |
| leaf update-wait-install-enabled { | | leaf update-wait-install-enabled { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP process update wait until install is | n | "Update wait-install enabled"; |
| configured"; | | |
| } | | |
| leaf update-wait-install-startup-delay { | | |
| type uint16; | | |
| units "second"; | | |
| description | | |
| "Update wait install startup delay in seconds"; | | |
| } | | } |
| leaf rib-acked-table-version { | | leaf rib-acked-table-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| n | "Table version acked by routing information base"; | n | "Table version acked by RIB"; |
| } | | } |
| leaf rib-ack-requests { | | leaf rib-ack-requests { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Count for RIB ack requests"; | n | "Counter for RIB ack requests"; |
| } | | } |
| leaf rib-acks-received { | | leaf rib-acks-received { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Count for RIB ack received"; | n | "Counter for RIB ack received"; |
| } | | } |
| leaf rib-slow-acks { | | leaf rib-slow-acks { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Count for slow RIB acks"; | n | "Counter for slow RIB acks"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-PROCESS-INFO-AF-BAG { | | grouping BGP-PROCESS-INFO-AF-BAG { |
| description | | description |
| "BGP address family specific process information"; | | "BGP address family specific process information"; |
| container global { | | container global { |
| description | | description |
| "Global information"; | | "Global information"; |
| uses BGP-PROCESS-INFO-AF-GBL; | | uses BGP-PROCESS-INFO-AF-GBL; |
| } | | } |
| container vrf { | | container vrf { |
| description | | description |
| "VRF information"; | | "VRF information"; |
| uses BGP-PROCESS-INFO-AF-VRF; | | uses BGP-PROCESS-INFO-AF-VRF; |
| } | | } |
| container performance-statistics { | | container performance-statistics { |
| description | | description |
| n | "BGP process address familyperformance statistics | n | "Performance statistics"; |
| info"; | | |
| uses BGP-PERF-PROCESS-AF; | | uses BGP-PERF-PROCESS-AF; |
| } | | } |
| leaf af-name { | | leaf af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Address family id"; | | "Address family id"; |
| } | | } |
| leaf process-instance { | | leaf process-instance { |
| type uint8; | | type uint8; |
| description | | description |
| "ID for the BGP process instance"; | | "ID for the BGP process instance"; |
| } | | } |
| leaf vrf-name { | | leaf vrf-name { |
| type string; | | type string; |
| description | | description |
| "Name of the VRF"; | | "Name of the VRF"; |
| } | | } |
| leaf vrf-totals { | | leaf vrf-totals { |
| type boolean; | | type boolean; |
| description | | description |
| "per VRF information aggregated across all VRFs"; | | "per VRF information aggregated across all VRFs"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-CONVERGENCE-BAG { | | grouping BGP-CONVERGENCE-BAG { |
| description | | description |
| "BGP Convergence"; | | "BGP Convergence"; |
| leaf af-name { | | leaf af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Address family identifier"; | | "Address family identifier"; |
| } | | } |
| leaf has-converged { | | leaf has-converged { |
| type boolean; | | type boolean; |
| description | | description |
| "Convergence has been reached"; | | "Convergence has been reached"; |
| } | | } |
| leaf are-write-queues-empty { | | leaf are-write-queues-empty { |
| type boolean; | | type boolean; |
| description | | description |
| "All neighbor write queues are empty"; | | "All neighbor write queues are empty"; |
| } | | } |
| n | leaf not-converged-neighbor { | n | |
| type string; | | |
| description | | |
| "Not converged Neighbor"; | | |
| } | | |
| leaf message-pending { | | |
| type boolean; | | |
| description | | |
| "Pending Message Send"; | | |
| } | | |
| leaf are-read-queues-empty { | | |
| type boolean; | | |
| description | | |
| "All neighbor read queues"; | | |
| } | | |
| leaf write-queue-size { | | |
| type uint32; | | |
| description | | |
| "Neighbor write queue size"; | | |
| } | | |
| leaf read-queue-size { | | |
| type int32; | | |
| description | | |
| "Neighbor read queue size"; | | |
| } | | |
| } | | } |
| | | |
| grouping BGP-ATTR-RNH-ADDR { | | grouping BGP-ATTR-RNH-ADDR { |
| description | | description |
| "BGP ATTR RNH ADDR"; | | "BGP ATTR RNH ADDR"; |
| leaf len { | | leaf len { |
| type Bgp-rnh-addr-len; | | type Bgp-rnh-addr-len; |
| description | | description |
| "len"; | | "len"; |
| } | | } |
| leaf ipv4-address { | | leaf ipv4-address { |
| when "../len = 'v4'" { | | when "../len = 'v4'" { |
| description | | description |
| "../len = 'v4'"; | | "../len = 'v4'"; |
| } | | } |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "IPv4 Addr"; | | "IPv4 Addr"; |
| } | | } |
| leaf ipv6-address { | | leaf ipv6-address { |
| when "../len = 'v6'" { | | when "../len = 'v6'" { |
| description | | description |
| "../len = 'v6'"; | | "../len = 'v6'"; |
| } | | } |
| type Ipv6-address; | | type Ipv6-address; |
| description | | description |
| "IPv6 Addr"; | | "IPv6 Addr"; |
| } | | } |
| leaf mac-address { | | leaf mac-address { |
| when "../len = 'mac'" { | | when "../len = 'mac'" { |
| description | | description |
| "../len = 'Mac'"; | | "../len = 'Mac'"; |
| } | | } |
| type Mac-address; | | type Mac-address; |
| description | | description |
| "MAC Addr"; | | "MAC Addr"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-BAG-LARGECOMM { | | grouping BGP-BAG-LARGECOMM { |
| description | | description |
| "Large Community"; | | "Large Community"; |
| leaf global-admin { | | leaf global-admin { |
| type uint32; | | type uint32; |
| description | | description |
| "Global Administrator"; | | "Global Administrator"; |
| } | | } |
| leaf local-data1 { | | leaf local-data1 { |
| type uint32; | | type uint32; |
| description | | description |
| "Local Data 1"; | | "Local Data 1"; |
| } | | } |
| leaf local-data2 { | | leaf local-data2 { |
| type uint32; | | type uint32; |
| description | | description |
| "Local Data 2"; | | "Local Data 2"; |
| } | | } |
| } | | } |
| | | |
| grouping SR-SID { | | grouping SR-SID { |
| description | | description |
| "Segement id value"; | | "Segement id value"; |
| leaf type { | | leaf type { |
| type Sr-sid; | | type Sr-sid; |
| description | | description |
| "Type"; | | "Type"; |
| } | | } |
| leaf label { | | leaf label { |
| when "../type = 'label'" { | | when "../type = 'label'" { |
| description | | description |
| "../Type = 'Label'"; | | "../Type = 'Label'"; |
| } | | } |
| type uint32; | | type uint32; |
| description | | description |
| "MPLS Label value"; | | "MPLS Label value"; |
| } | | } |
| leaf ipv4-address { | | leaf ipv4-address { |
| when "../type = 'ipv4'" { | | when "../type = 'ipv4'" { |
| description | | description |
| "../Type = 'IPv4'"; | | "../Type = 'IPv4'"; |
| } | | } |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "IPv4 Address value"; | | "IPv4 Address value"; |
| } | | } |
| leaf ipv6-address { | | leaf ipv6-address { |
| when "../type = 'ipv6'" { | | when "../type = 'ipv6'" { |
| description | | description |
| "../Type = 'IPv6'"; | | "../Type = 'IPv6'"; |
| } | | } |
| type Ipv6-address; | | type Ipv6-address; |
| description | | description |
| "IPv6 address value"; | | "IPv6 address value"; |
| } | | } |
| } | | } |
| | | |
| grouping SR-EXPPATH { | | grouping SR-EXPPATH { |
| description | | description |
| "SR Policy Explicit Path"; | | "SR Policy Explicit Path"; |
| leaf weight { | | leaf weight { |
| type uint8; | | type uint8; |
| description | | description |
| "Weight of segment list"; | | "Weight of segment list"; |
| } | | } |
| list segment { | | list segment { |
| description | | description |
| "Segments in segment list"; | | "Segments in segment list"; |
| uses SR-SID; | | uses SR-SID; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-BINDING-SID { | | grouping BGP-BINDING-SID { |
| description | | description |
| "BGP BINDING SID"; | | "BGP BINDING SID"; |
| leaf type { | | leaf type { |
| type Bgp-binding-sid; | | type Bgp-binding-sid; |
| description | | description |
| "Type"; | | "Type"; |
| } | | } |
| leaf label { | | leaf label { |
| when "../type = 'label'" { | | when "../type = 'label'" { |
| description | | description |
| "../Type = 'label'"; | | "../Type = 'label'"; |
| } | | } |
| type uint32; | | type uint32; |
| description | | description |
| "MPLS Label"; | | "MPLS Label"; |
| } | | } |
| leaf ipv6-address { | | leaf ipv6-address { |
| when "../type = 'v6'" { | | when "../type = 'v6'" { |
| description | | description |
| "../Type = 'v6'"; | | "../Type = 'v6'"; |
| } | | } |
| type Ipv6-address; | | type Ipv6-address; |
| description | | description |
| "IPv6 Addr"; | | "IPv6 Addr"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-SRPOLICY-ENTRY { | | grouping BGP-SRPOLICY-ENTRY { |
| description | | description |
| "SR policy Entry"; | | "SR policy Entry"; |
| container binding-sid { | | container binding-sid { |
| description | | description |
| "SR Policy incoming Binding sid"; | | "SR Policy incoming Binding sid"; |
| uses BGP-BINDING-SID; | | uses BGP-BINDING-SID; |
| } | | } |
| container allocated-binding-sid { | | container allocated-binding-sid { |
| description | | description |
| "SR Policy allocated Binding sid by the router"; | | "SR Policy allocated Binding sid by the router"; |
| uses BGP-BINDING-SID; | | uses BGP-BINDING-SID; |
| } | | } |
| leaf tunnel-encap-type { | | leaf tunnel-encap-type { |
| type uint16; | | type uint16; |
| description | | description |
| "Tunnel Encapsulation Type"; | | "Tunnel Encapsulation Type"; |
| } | | } |
| leaf preference { | | leaf preference { |
| type uint32; | | type uint32; |
| description | | description |
| "SR Policy Preference"; | | "SR Policy Preference"; |
| } | | } |
| leaf state { | | leaf state { |
| type boolean; | | type boolean; |
| description | | description |
| "SR Policy active state in forwarding"; | | "SR Policy active state in forwarding"; |
| } | | } |
| leaf request-state { | | leaf request-state { |
| type Bgp-srpolicy-req-state; | | type Bgp-srpolicy-req-state; |
| description | | description |
| "SR Policy programming Status"; | | "SR Policy programming Status"; |
| } | | } |
| leaf usable { | | leaf usable { |
| type boolean; | | type boolean; |
| description | | description |
| "SR Policy is usable on this node"; | | "SR Policy is usable on this node"; |
| } | | } |
| list segment-list { | | list segment-list { |
| description | | description |
| "SR Policy Segment Lists"; | | "SR Policy Segment Lists"; |
| uses SR-EXPPATH; | | uses SR-EXPPATH; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-TUNENCAP-ENTRY { | | grouping BGP-TUNENCAP-ENTRY { |
| description | | description |
| "Tunnel Encap attribute entry"; | | "Tunnel Encap attribute entry"; |
| container sr-policy { | | container sr-policy { |
| description | | description |
| "Tunnel encap type SR policy"; | | "Tunnel encap type SR policy"; |
| uses BGP-SRPOLICY-ENTRY; | | uses BGP-SRPOLICY-ENTRY; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-BAG-PSID-UNK-TLVS { | | grouping BGP-BAG-PSID-UNK-TLVS { |
| description | | description |
| "Prefix-SID Unknown TLVs buffer"; | | "Prefix-SID Unknown TLVs buffer"; |
| leaf tlv-count { | | leaf tlv-count { |
| type uint16; | | type uint16; |
| description | | description |
| "Number of unknown TLVs stored"; | | "Number of unknown TLVs stored"; |
| } | | } |
| leaf received-buffer-length { | | leaf received-buffer-length { |
| type uint32; | | type uint32; |
| description | | description |
| "Received length of unknown TLVs"; | | "Received length of unknown TLVs"; |
| } | | } |
| list tl-vs-buffer { | | list tl-vs-buffer { |
| description | | description |
| "Limited buffer of unknown TLVs"; | | "Limited buffer of unknown TLVs"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "Limited buffer of unknown TLVs"; | | "Limited buffer of unknown TLVs"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| n | grouping BGP-BAG-PSID-SRV6-L3SVC { | n | grouping BGP-BAG-PSID-SRV6-VPN-TSID { |
| | | description |
| | | "Prefix-SID SRv6 VPN Type And SID info"; |
| | | leaf sid-type { |
| | | type uint8; |
| description | | description |
| | | "SID Type"; |
| | | } |
| | | leaf sid-flags { |
| | | type uint8; |
| | | description |
| | | "SID Flags"; |
| | | } |
| | | leaf sid-value { |
| | | type inet:ipv6-address; |
| | | description |
| | | "SID Value"; |
| | | } |
| | | } |
| | | |
| | | grouping BGP-BAG-PSID-SRV6-VPN-SID { |
| | | description |
| "Prefix-SID SRv6-l3svc TLV info"; | | "Prefix-SID SRv6-VPN-SID TLV info"; |
| leaf reserved { | | leaf reserved { |
| type uint8; | | type uint8; |
| description | | description |
| "Reserved field"; | | "Reserved field"; |
| } | | } |
| n | leaf sub-tlv-count { | n | leaf sid-count { |
| type uint16; | | |
| description | | |
| "Number of subtlvs"; | | |
| } | | |
| list sub-tlv { | | |
| description | | |
| "Sub TLVs"; | | |
| uses BGP-BAG-PSID-SRV6-SVC-SUBTLV-INFO; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-BAG-PSID-SRV6-SVC-SIDINFO-SUBSUBTLV-SID-STRUCT { | | |
| description | | |
| "BGP BAG PSID SRV6 SVC SIDINFO SUBSUBTLV SID | | |
| STRUCT"; | | |
| leaf loc-blk-len { | | |
| type uint8; | | type uint32; |
| description | | |
| "locator blk len"; | | |
| } | | |
| leaf loc-node-len { | | |
| type uint8; | | |
| description | | |
| "locator node len"; | | |
| } | | |
| leaf func-len { | | |
| type uint8; | | |
| description | | |
| "Function len"; | | |
| } | | |
| leaf arg-len { | | |
| type uint8; | | |
| description | | |
| "Argument len"; | | |
| } | | |
| leaf transpose-len { | | |
| type uint8; | | |
| description | | |
| "Transpose len"; | | |
| } | | |
| leaf transpose-offset { | | |
| type uint8; | | |
| description | | |
| "Transpose offset"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-BAG-PSID-SRV6-SVC-SIDINFO-SUBSUBTLV-VAL { | | |
| description | | |
| "Prefix-SID SRv6-svc SUBSUB TLV types"; | | |
| container sid-struct { | | |
| description | | |
| "SIDStruct field"; | | |
| uses BGP-BAG-PSID-SRV6-SVC-SIDINFO-SUBSUBTLV-SID-STRUCT; | | |
| } | | |
| list unknown-buf { | | |
| description | | |
| "Unknown buff"; | | |
| leaf entry { | | |
| type uint8; | | |
| description | | |
| "Unknown buff"; | | |
| } | | |
| } | | |
| } | | |
| | | |
| grouping BGP-BAG-PSID-SRV6-SVC-SIDINFO-SUBSUBTLV-INFO { | | |
| description | | |
| "Prefix-SID SRv6-svc SUBSUB TLV info"; | | |
| container sub-sub-tlv-val { | | |
| description | | |
| "Subsub TLV Val"; | | |
| uses BGP-BAG-PSID-SRV6-SVC-SIDINFO-SUBSUBTLV-VAL; | | |
| } | | |
| leaf type { | | |
| type uint8; | | |
| description | | |
| "SUBSUBtlv Type"; | | |
| } | | |
| leaf length { | | |
| type uint16; | | |
| description | | |
| "SUBSUBTLv length"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-BAG-PSID-SRV6-SVC-SUBSUBTLV-INFO { | | |
| description | | |
| "Prefix-SID SRv6-svc SUBSUB TLV val"; | | |
| leaf reserved2 { | | |
| type uint8; | | |
| description | | |
| "SUB TLV reserved"; | | |
| } | | |
| leaf sid { | | |
| type inet:ipv6-address; | | |
| description | | |
| "SID new Value"; | | |
| } | | |
| leaf sid-flags { | | |
| type uint8; | | |
| description | | |
| "SID Flags"; | | |
| } | | |
| leaf sid-behavior { | | |
| type uint16; | | |
| description | | |
| "SID ENDPT behavior"; | | |
| } | | |
| leaf reserved3 { | | |
| type uint8; | | |
| description | | |
| "SUB SUB TLV reserved"; | | |
| } | | |
| leaf sub-sub-tlv-count { | | |
| type uint16; | | |
| description | | |
| "SUB SUB TLV Count"; | | |
| } | | |
| list sub-sub-tlv { | | |
| description | | |
| "List of sub sub tlvs"; | | |
| uses BGP-BAG-PSID-SRV6-SVC-SIDINFO-SUBSUBTLV-INFO; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-BAG-PSID-SRV6-SVC-SUBTLV-VAL { | | |
| description | | |
| "Prefix-SID SRv6-svc SUB TLV info"; | | |
| container sid-info { | | |
| description | | |
| "SIDinfo field"; | | |
| uses BGP-BAG-PSID-SRV6-SVC-SUBSUBTLV-INFO; | | |
| } | | |
| list unknown-buf { | | |
| description | | |
| "Unknown buff"; | | |
| leaf entry { | | |
| type uint8; | | |
| description | | |
| "Unknown buff"; | | |
| } | | |
| } | | |
| } | | |
| | | |
| grouping BGP-BAG-PSID-SRV6-SVC-SUBTLV-INFO { | | |
| description | | |
| "Prefix-SID SRv6-svc TLV val"; | | |
| container sub-tlv-val { | | |
| description | | |
| "Sub TLV Val"; | | |
| uses BGP-BAG-PSID-SRV6-SVC-SUBTLV-VAL; | | |
| } | | |
| leaf type { | | |
| type uint8; | | |
| description | | |
| "Type field"; | | |
| } | | |
| leaf len { | | |
| type uint16; | | |
| description | | |
| "length of SUB_TLVs"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-BAG-PSID-SRV6-L2SVC { | | |
| description | | |
| "Prefix-SID SRv6-l2svc TLV info"; | | |
| leaf reserved { | | |
| type uint8; | | |
| description | | |
| "Reserved field"; | | |
| } | | |
| leaf sub-tlv-count { | | |
| type uint16; | | |
| description | | description |
| "Number of SIDs"; | | "Number of SIDs"; |
| } | | } |
| n | list sub-tlv { | n | list sid { |
| description | | description |
| n | "Sub TLVs"; | n | "List of SIDs"; |
| uses BGP-BAG-PSID-SRV6-SVC-SUBTLV-INFO; | | uses BGP-BAG-PSID-SRV6-VPN-TSID; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-BAG-SRGB-RANGE { | | grouping BGP-BAG-SRGB-RANGE { |
| description | | description |
| "SRGB Range"; | | "SRGB Range"; |
| leaf range-start { | | leaf range-start { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Start of the range for BGP Segment Routing (SR) | n | "Range start"; |
| global block"; | | |
| } | | } |
| leaf range-end { | | leaf range-end { |
| type uint32; | | type uint32; |
| description | | description |
| n | "End of the range for BGP Segment Routing | n | "Range end"; |
| (SR)global block"; | | |
| } | | } |
| } | | } |
| | | |
| grouping BGP-BAG-PSID-ORIG-SRGB { | | grouping BGP-BAG-PSID-ORIG-SRGB { |
| description | | description |
| "Prefix-SID Orig-SRGB TLV info"; | | "Prefix-SID Orig-SRGB TLV info"; |
| leaf flags { | | leaf flags { |
| type uint16; | | type uint16; |
| description | | description |
| "Flags field"; | | "Flags field"; |
| } | | } |
| leaf range-count { | | leaf range-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of SRGB ranges"; | | "Number of SRGB ranges"; |
| } | | } |
| list range { | | list range { |
| description | | description |
| "List of SRGB ranges"; | | "List of SRGB ranges"; |
| uses BGP-BAG-SRGB-RANGE; | | uses BGP-BAG-SRGB-RANGE; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-BAG-PSID-LABEL-INDEX { | | grouping BGP-BAG-PSID-LABEL-INDEX { |
| description | | description |
| "Prefix-SID Label-Index info"; | | "Prefix-SID Label-Index info"; |
| leaf reserved { | | leaf reserved { |
| type uint8; | | type uint8; |
| description | | description |
| "Reserved field"; | | "Reserved field"; |
| } | | } |
| leaf flags { | | leaf flags { |
| type uint16; | | type uint16; |
| description | | description |
| "Flags field"; | | "Flags field"; |
| } | | } |
| leaf label-index { | | leaf label-index { |
| type uint32; | | type uint32; |
| description | | description |
| "LabelIndex field"; | | "LabelIndex field"; |
| } | | } |
| } | | } |
| | | |
| n | grouping BGP-SECOND-LBL-ENTRY { | n | |
| description | | |
| "Secondary Label entry"; | | |
| leaf label-type { | | |
| type uint8; | | |
| description | | |
| "Type of the seclabel"; | | |
| } | | |
| leaf label { | | |
| type uint32; | | |
| description | | |
| "Label"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-PEDISTLBL-ENTRY { | | grouping BGP-PEDISTLBL-ENTRY { |
| description | | description |
| "PE distinguisher Label entry"; | | "PE distinguisher Label entry"; |
| leaf pe-address { | | leaf pe-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| " PE address"; | | " PE address"; |
| } | | } |
| leaf label { | | leaf label { |
| type uint32; | | type uint32; |
| description | | description |
| "Label"; | | "Label"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-COMMON-ATTR-ENTRY { | | grouping BGP-COMMON-ATTR-ENTRY { |
| description | | description |
| "Common Set of attribute entry"; | | "Common Set of attribute entry"; |
| container prefix-sid-label-index { | | container prefix-sid-label-index { |
| description | | description |
| "Prefix-SID LabelIndex TLV info"; | | "Prefix-SID LabelIndex TLV info"; |
| uses BGP-BAG-PSID-LABEL-INDEX; | | uses BGP-BAG-PSID-LABEL-INDEX; |
| } | | } |
| container prefix-sid-orig-srgb { | | container prefix-sid-orig-srgb { |
| description | | description |
| "Prefix-SID OrigSRGB TLV info"; | | "Prefix-SID OrigSRGB TLV info"; |
| uses BGP-BAG-PSID-ORIG-SRGB; | | uses BGP-BAG-PSID-ORIG-SRGB; |
| } | | } |
| n | container prefix-sid-srv6-layer2-svc { | n | container prefix-sids-rv6vpnsid { |
| description | | description |
| n | "Prefix-SID SRv6L2SVC TLV info"; | n | "Prefix-SID SRv6VPNSID TLV info"; |
| uses BGP-BAG-PSID-SRV6-L2SVC; | | uses BGP-BAG-PSID-SRV6-VPN-SID; |
| } | | } |
| n | container prefix-sid-srv6-layer3-svc { | n | |
| description | | |
| "Prefix-SID SRv6L3SVC TLV info"; | | |
| uses BGP-BAG-PSID-SRV6-L3SVC; | | |
| } | | |
| container prefix-sid-unk-tlvs { | | container prefix-sid-unk-tl-vs { |
| description | | description |
| "Prefix-SID UnkTLVs TLV info"; | | "Prefix-SID UnkTLVs TLV info"; |
| uses BGP-BAG-PSID-UNK-TLVS; | | uses BGP-BAG-PSID-UNK-TLVS; |
| } | | } |
| container tunnel-encap { | | container tunnel-encap { |
| description | | description |
| "Tunnel Encapsulation attribute"; | | "Tunnel Encapsulation attribute"; |
| uses BGP-TUNENCAP-ENTRY; | | uses BGP-TUNENCAP-ENTRY; |
| } | | } |
| leaf is-metric-present { | | leaf is-metric-present { |
| type boolean; | | type boolean; |
| description | | description |
| "Metric attribute present"; | | "Metric attribute present"; |
| } | | } |
| leaf is-local-pref-present { | | leaf is-local-pref-present { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if BGP local preference | n | "Local Preference attribute present"; |
| attribute is present"; | | |
| } | | } |
| leaf is-atomic-aggregate-present { | | leaf is-atomic-aggregate-present { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if Atomic aggregate attribute | n | "Atomic aggregate attribute present"; |
| present"; | | |
| } | | } |
| leaf is-aggregator-present { | | leaf is-aggregator-present { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if Aggregator attribute present"; | n | "Aggregator attribute present"; |
| } | | } |
| leaf is-origin-present { | | leaf is-origin-present { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if Origin attribute is present"; | n | "Origin attribute present"; |
| } | | } |
| leaf is-as-path-present { | | leaf is-as-path-present { |
| type boolean; | | type boolean; |
| description | | description |
| "AS path attribute present"; | | "AS path attribute present"; |
| } | | } |
| leaf is-community-present { | | leaf is-community-present { |
| type boolean; | | type boolean; |
| description | | description |
| "Community attribute present"; | | "Community attribute present"; |
| } | | } |
| leaf is-extended-community-present { | | leaf is-extended-community-present { |
| type boolean; | | type boolean; |
| description | | description |
| "Extended community attribute present"; | | "Extended community attribute present"; |
| } | | } |
| leaf is-ssa-present { | | leaf is-ssa-present { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if SSA attribute is present"; | n | "SSA attribute present"; |
| } | | } |
| leaf is-connector-present { | | leaf is-connector-present { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if BGP attribute Connector is | n | |
| present"; | | "Connector present"; |
| } | | } |
| leaf is-pmsi-present { | | leaf is-pmsi-present { |
| type boolean; | | type boolean; |
| description | | description |
| "PMSI Attribute present"; | | "PMSI Attribute present"; |
| } | | } |
| leaf is-pppmp-present { | | leaf is-pppmp-present { |
| type boolean; | | type boolean; |
| description | | description |
| "PPMP Attribute present"; | | "PPMP Attribute present"; |
| } | | } |
| leaf is-aigp-present { | | leaf is-aigp-present { |
| type boolean; | | type boolean; |
| description | | description |
| "AIGP Present"; | | "AIGP Present"; |
| } | | } |
| leaf is-pe-distinguisher-label-present { | | leaf is-pe-distinguisher-label-present { |
| type boolean; | | type boolean; |
| description | | description |
| "PE distinguisher label attribute present"; | | "PE distinguisher label attribute present"; |
| } | | } |
| n | leaf is-secondary-label-present { | n | |
| type boolean; | | |
| description | | |
| "Secondary label attribute present"; | | |
| } | | |
| leaf is-ls-attribute-present { | | leaf is-ls-attribute-present { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if BGP link-state attribute | n | "BGP LS attribute present"; |
| information is present"; | | |
| } | | } |
| leaf is-label-index-present { | | leaf is-label-index-present { |
| type boolean; | | type boolean; |
| description | | description |
| "Label Index attribute - present - deprecated"; | | "Label Index attribute - present - deprecated"; |
| } | | } |
| n | leaf is-prefix-sid-label-index-present { | n | leaf is-prefix-sid-label-indexpresent { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix-SID LabelIndex present"; | | "Prefix-SID LabelIndex present"; |
| } | | } |
| n | leaf is-prefix-sid-orig-srgb-present { | n | leaf is-prefix-sid-orig-srg-bpresent { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix-SID OrigSRGB present"; | | "Prefix-SID OrigSRGB present"; |
| } | | } |
| n | leaf is-prefix-sid-srv6-layer3-svc-present { | n | leaf is-prefix-sids-rv6vpnsi-dpresent { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Prefix-SID SRv6L3SVC present"; | n | "Prefix-SID SRv6VPNSID present"; |
| } | | } |
| n | leaf is-prefix-sid-srv6-layer2-svc-present { | n | |
| type boolean; | | |
| description | | |
| "Prefix-SID SRv6L2SVC present"; | | |
| } | | |
| leaf is-prefix-sid-unk-tlvs-present { | | leaf is-prefix-sid-unk-tl-vspresent { |
| type boolean; | | type boolean; |
| description | | description |
| "Prefix-SID UnkTLVs present"; | | "Prefix-SID UnkTLVs present"; |
| } | | } |
| leaf neighbor-as { | | leaf neighbor-as { |
| type uint32; | | type uint32; |
| description | | description |
| "Neighbor AS number"; | | "Neighbor AS number"; |
| } | | } |
| leaf aggregator-as { | | leaf aggregator-as { |
| type uint32; | | type uint32; |
| description | | description |
| "AS where aggregation was last performed"; | | "AS where aggregation was last performed"; |
| } | | } |
| leaf aggregator-address { | | leaf aggregator-address { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| n | "Address where aggregation was performed "; | n | "Address where aggregation was performed"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Metric associated with BGP attribute "; | n | "Metric"; |
| } | | } |
| leaf local-preference { | | leaf local-preference { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Flag to indicate BGP attribute is local"; | n | "Local preference"; |
| } | | } |
| leaf origin { | | leaf origin { |
| type uint16; | | type uint16; |
| description | | description |
| n | "BGP common attribute Origin "; | n | "Origin"; |
| } | | } |
| leaf as-path { | | leaf as-path { |
| type string; | | type string; |
| description | | description |
| n | "BGP Atonomous system path attribute"; | n | "AS path attribute"; |
| } | | } |
| leaf extended-community-flags { | | leaf extended-community-flags { |
| type uint8; | | type uint8; |
| description | | description |
| n | "BGP attribute Extended community Flags"; | n | "Extended community Flags"; |
| } | | } |
| leaf originator { | | leaf originator { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Originator attribute"; | | "Originator attribute"; |
| } | | } |
| leaf l2tpv3-session-id { | | leaf l2tpv3-session-id { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP attribute Layer2 tunneling protocol version | n | |
| 3 session id"; | | "L2TPv3 session id"; |
| } | | } |
| leaf connector-type { | | leaf connector-type { |
| type uint16; | | type uint16; |
| description | | description |
| n | "BGP attribute Connector Type"; | n | "Connector Type"; |
| } | | } |
| leaf aigp-metric-value { | | leaf aigp-metric-value { |
| type uint64; | | type uint64; |
| description | | description |
| "AIGP metric value"; | | "AIGP metric value"; |
| } | | } |
| leaf pmsi-type { | | leaf pmsi-type { |
| type uint16; | | type uint16; |
| description | | description |
| "PMSI Type"; | | "PMSI Type"; |
| } | | } |
| leaf pmsi-flags { | | leaf pmsi-flags { |
| type uint8; | | type uint8; |
| description | | description |
| "PMSI Value"; | | "PMSI Value"; |
| } | | } |
| leaf pmsi-label { | | leaf pmsi-label { |
| type uint32; | | type uint32; |
| description | | description |
| "PMSI label"; | | "PMSI label"; |
| } | | } |
| leaf ppm-pvalue { | | leaf ppm-pvalue { |
| type uint32; | | type uint32; |
| description | | description |
| "PPMP Value"; | | "PPMP Value"; |
| } | | } |
| leaf is-large-community-present { | | leaf is-large-community-present { |
| type boolean; | | type boolean; |
| description | | description |
| "Large Community attribute present"; | | "Large Community attribute present"; |
| } | | } |
| list community { | | list community { |
| description | | description |
| "Community attribute"; | | "Community attribute"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Community attribute"; | | "Community attribute"; |
| } | | } |
| } | | } |
| list extended-community { | | list extended-community { |
| description | | description |
| "Extended community attribute"; | | "Extended community attribute"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "Extended community attribute"; | | "Extended community attribute"; |
| } | | } |
| } | | } |
| list unknown-attribute { | | list unknown-attribute { |
| description | | description |
| n | "BGP common set of unknown attributes "; | n | "Unknown attributes"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| n | "BGP common set of unknown attributes "; | n | "Unknown attributes"; |
| } | | } |
| } | | } |
| list cluster { | | list cluster { |
| description | | description |
| "Cluster list attribute"; | | "Cluster list attribute"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Cluster list attribute"; | | "Cluster list attribute"; |
| } | | } |
| } | | } |
| list l2tpv3-cookie { | | list l2tpv3-cookie { |
| description | | description |
| "L2TPv3 Cookie"; | | "L2TPv3 Cookie"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "L2TPv3 Cookie"; | | "L2TPv3 Cookie"; |
| } | | } |
| } | | } |
| list connector-value { | | list connector-value { |
| description | | description |
| n | "BGP attribute Connector Value"; | n | "Connector Value"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| n | "BGP attribute Connector Value"; | n | "Connector Value"; |
| } | | } |
| } | | } |
| list pmsi-value { | | list pmsi-value { |
| description | | description |
| "PMSI Value"; | | "PMSI Value"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "PMSI Value"; | | "PMSI Value"; |
| } | | } |
| } | | } |
| list ls-attr { | | list ls-attr { |
| description | | description |
| "BGP LS attribute"; | | "BGP LS attribute"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "BGP LS attribute"; | | "BGP LS attribute"; |
| } | | } |
| } | | } |
| list pe-distinguisher-label { | | list pe-distinguisher-label { |
| description | | description |
| "PE distinguisher label attribute"; | | "PE distinguisher label attribute"; |
| uses BGP-PEDISTLBL-ENTRY; | | uses BGP-PEDISTLBL-ENTRY; |
| } | | } |
| n | list secondary-label { | n | |
| description | | |
| "Secondary label attribute"; | | |
| uses BGP-SECOND-LBL-ENTRY; | | |
| } | | |
| list large-community { | | list large-community { |
| description | | description |
| "Large Community attribute"; | | "Large Community attribute"; |
| uses BGP-BAG-LARGECOMM; | | uses BGP-BAG-LARGECOMM; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-ATTR { | | grouping BGP-ATTR { |
| description | | description |
| "BGP Attributes"; | | "BGP Attributes"; |
| container common-attributes { | | container common-attributes { |
| description | | description |
| n | "BGP entry to derive the attribute information"; | n | "Common attributes"; |
| uses BGP-COMMON-ATTR-ENTRY; | | uses BGP-COMMON-ATTR-ENTRY; |
| } | | } |
| container attr-set { | | container attr-set { |
| description | | description |
| "ATTR_SET attribute"; | | "ATTR_SET attribute"; |
| uses BGP-COMMON-ATTR-ENTRY; | | uses BGP-COMMON-ATTR-ENTRY; |
| } | | } |
| container rnh-addr { | | container rnh-addr { |
| description | | description |
| "RNH Address"; | | "RNH Address"; |
| uses BGP-ATTR-RNH-ADDR; | | uses BGP-ATTR-RNH-ADDR; |
| } | | } |
| container ribrnh-ip { | | container ribrnh-ip { |
| description | | description |
| "RIB RNH IP Address"; | | "RIB RNH IP Address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| leaf is-as-path2-byte { | | leaf is-as-path2-byte { |
| type boolean; | | type boolean; |
| description | | description |
| "AS path encoded as 2-byte"; | | "AS path encoded as 2-byte"; |
| } | | } |
| leaf is-application-gateway-present { | | leaf is-application-gateway-present { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if BGP application gateway is | n | "Application gateway present"; |
| present"; | | |
| } | | } |
| leaf is-attr-set-present { | | leaf is-attr-set-present { |
| type boolean; | | type boolean; |
| description | | description |
| "BGP ATTR_SET attribute present"; | | "BGP ATTR_SET attribute present"; |
| } | | } |
| leaf set-aigp-inbound-igp { | | leaf set-aigp-inbound-igp { |
| type boolean; | | type boolean; |
| description | | description |
| "AIGP set by policy inbound IGP "; | | "AIGP set by policy inbound IGP "; |
| } | | } |
| leaf set-aigp-inbound-metric { | | leaf set-aigp-inbound-metric { |
| type boolean; | | type boolean; |
| description | | description |
| "AIGP set by policy inbound metric"; | | "AIGP set by policy inbound metric"; |
| } | | } |
| leaf is-rnh-present { | | leaf is-rnh-present { |
| type boolean; | | type boolean; |
| description | | description |
| "RNH Attribute present"; | | "RNH Attribute present"; |
| } | | } |
| leaf is-ribrnh-present { | | leaf is-ribrnh-present { |
| type boolean; | | type boolean; |
| description | | description |
| "RIB RNH Attribute present"; | | "RIB RNH Attribute present"; |
| } | | } |
| leaf attribute-key-number { | | leaf attribute-key-number { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number which is stored per bgp routing table on | n | |
| attribute key"; | | "Attribute key number"; |
| } | | } |
| leaf attribute-reuse-id-config { | | leaf attribute-reuse-id-config { |
| type boolean; | | type boolean; |
| description | | description |
| "Attribute reuse ID Configured"; | | "Attribute reuse ID Configured"; |
| } | | } |
| leaf attribute-reuse-id-max-id { | | leaf attribute-reuse-id-max-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Attribute reuse ID maximum ID"; | | "Attribute reuse ID maximum ID"; |
| } | | } |
| leaf attribute-reuse-id-node { | | leaf attribute-reuse-id-node { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP Attribute reuse ID nodes"; | n | "Attribute reuse ID nodes"; |
| } | | } |
| leaf attribute-reuse-id-current { | | leaf attribute-reuse-id-current { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP Attribute reuse ID current ID"; | n | "Attribute reuse ID current ID"; |
| } | | } |
| leaf attribute-reuse-id-keys { | | leaf attribute-reuse-id-keys { |
| type uint32; | | type uint32; |
| description | | description |
| "Attribute reuse ID allocated keys"; | | "Attribute reuse ID allocated keys"; |
| } | | } |
| leaf attribute-reuse-id-recover-sec { | | leaf attribute-reuse-id-recover-sec { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Attribute reuse ID timer in seconds"; | | "Attribute reuse ID timer in seconds"; |
| } | | } |
| leaf vpn-distinguisher { | | leaf vpn-distinguisher { |
| type uint32; | | type uint32; |
| description | | description |
| "VPN Distinguisher"; | | "VPN Distinguisher"; |
| } | | } |
| leaf rnh-type { | | leaf rnh-type { |
| type uint16; | | type uint16; |
| description | | description |
| "RNH Type"; | | "RNH Type"; |
| } | | } |
| leaf rnh-len { | | leaf rnh-len { |
| type uint8; | | type uint8; |
| description | | description |
| "RNH Length"; | | "RNH Length"; |
| } | | } |
| leaf rnh-addr-len { | | leaf rnh-addr-len { |
| type uint32; | | type uint32; |
| description | | description |
| "RNH Address Length"; | | "RNH Address Length"; |
| } | | } |
| leaf ribrnh-table { | | leaf ribrnh-table { |
| type uint32; | | type uint32; |
| description | | description |
| "RIB RNH Table"; | | "RIB RNH Table"; |
| } | | } |
| leaf ribrnh-mac { | | leaf ribrnh-mac { |
| type Mac-address; | | type Mac-address; |
| description | | description |
| "RIB RNH MAC Address"; | | "RIB RNH MAC Address"; |
| } | | } |
| leaf ribrnhip-table { | | leaf ribrnhip-table { |
| type uint32; | | type uint32; |
| description | | description |
| "RIB RNH IP Table"; | | "RIB RNH IP Table"; |
| } | | } |
| leaf ribrnh-vni { | | leaf ribrnh-vni { |
| type uint32; | | type uint32; |
| description | | description |
| "RIB RNH Vni"; | | "RIB RNH Vni"; |
| } | | } |
| leaf ribrnh-encap { | | leaf ribrnh-encap { |
| type uint8; | | type uint8; |
| description | | description |
| "RIB RNH Encapsulation Type"; | | "RIB RNH Encapsulation Type"; |
| } | | } |
| n | leaf entropy-label-capability { | n | |
| type boolean; | | |
| description | | |
| "Entropy label Capability"; | | |
| } | | |
| } | | } |
| | | |
| grouping BGP-ADVINFO-TYPE { | | grouping BGP-ADVINFO-TYPE { |
| description | | description |
| "Peers being advertised to"; | | "Peers being advertised to"; |
| container neighbor-address { | | container neighbor-address { |
| description | | description |
| n | "BGP advertised neighbor Address"; | n | "Neighbor Address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| leaf is-neighbor { | | leaf is-neighbor { |
| type boolean; | | type boolean; |
| description | | description |
| "Entry is a neighbor (not an update group)"; | | "Entry is a neighbor (not an update group)"; |
| } | | } |
| leaf update-group-afi { | | leaf update-group-afi { |
| type uint8; | | type uint8; |
| description | | description |
| "AFI of the Update group it is advertised to"; | | "AFI of the Update group it is advertised to"; |
| } | | } |
| leaf update-group-number { | | leaf update-group-number { |
| type uint32; | | type uint32; |
| description | | description |
| "Update group index"; | | "Update group index"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-V4-V6 { | | grouping BGP-V4-V6 { |
| description | | description |
| n | "The length of the BGP address"; | n | "BGP V4 V6"; |
| leaf len { | | leaf len { |
| type Bgp-v4-v6-len; | | type Bgp-v4-v6-len; |
| description | | description |
| "len"; | | "len"; |
| } | | } |
| leaf ipv4-address { | | leaf ipv4-address { |
| when "../len = 'gwipv4'" { | | when "../len = 'gwipv4'" { |
| description | | description |
| "../len = 'gwipv4'"; | | "../len = 'gwipv4'"; |
| } | | } |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "IPv4 Addr"; | | "IPv4 Addr"; |
| } | | } |
| leaf ipv6-address { | | leaf ipv6-address { |
| when "../len = 'gwipv6'" { | | when "../len = 'gwipv6'" { |
| description | | description |
| "../len = 'gwipv6'"; | | "../len = 'gwipv6'"; |
| } | | } |
| type Ipv6-address; | | type Ipv6-address; |
| description | | description |
| "IPv6 Addr"; | | "IPv6 Addr"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-TE-TUNNEL { | | grouping BGP-TE-TUNNEL { |
| description | | description |
| "BGP TE TUNNEL"; | | "BGP TE TUNNEL"; |
| leaf tunnel-type { | | leaf tunnel-type { |
| type Bgp-tunnel; | | type Bgp-tunnel; |
| description | | description |
| "Nexthop Tunnel Type"; | | "Nexthop Tunnel Type"; |
| } | | } |
| leaf tunnel-name { | | leaf tunnel-name { |
| type string; | | type string; |
| description | | description |
| "Tunnel name attribute"; | | "Tunnel name attribute"; |
| } | | } |
| leaf is-tunnel-up { | | leaf is-tunnel-up { |
| type boolean; | | type boolean; |
| description | | description |
| "Tunnel Up flag"; | | "Tunnel Up flag"; |
| } | | } |
| leaf is-tunnel-info-stale { | | leaf is-tunnel-info-stale { |
| type boolean; | | type boolean; |
| description | | description |
| "Tunnel is stale"; | | "Tunnel is stale"; |
| } | | } |
| leaf is-tunnel-registered { | | leaf is-tunnel-registered { |
| type boolean; | | type boolean; |
| description | | description |
| "Tunnel registered flag"; | | "Tunnel registered flag"; |
| } | | } |
| leaf is-bgp-te-registered { | | leaf is-bgp-te-registered { |
| type boolean; | | type boolean; |
| description | | description |
| "BGPTE registered flag"; | | "BGPTE registered flag"; |
| } | | } |
| leaf tunnel-v6-required { | | leaf tunnel-v6-required { |
| type boolean; | | type boolean; |
| description | | description |
| "Tunnel need IPv6"; | | "Tunnel need IPv6"; |
| } | | } |
| leaf tunnel-v6-enabled { | | leaf tunnel-v6-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "IPv6 enabled"; | | "IPv6 enabled"; |
| } | | } |
| leaf tunnel-notif-first-rcvd { | | leaf tunnel-notif-first-rcvd { |
| type boolean; | | type boolean; |
| description | | description |
| "Tunnel first notif received"; | | "Tunnel first notif received"; |
| } | | } |
| leaf tunnel-state-skip-reg { | | leaf tunnel-state-skip-reg { |
| type boolean; | | type boolean; |
| description | | description |
| "Skip tunnel registration for Stale entry"; | | "Skip tunnel registration for Stale entry"; |
| } | | } |
| leaf binding-label { | | leaf binding-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Binding label for the tunnel"; | | "Binding label for the tunnel"; |
| } | | } |
| leaf tunnel-if-handle { | | leaf tunnel-if-handle { |
| type uint32; | | type uint32; |
| description | | description |
| "Interface handle for the tunnel"; | | "Interface handle for the tunnel"; |
| } | | } |
| leaf last-tunnel-update { | | leaf last-tunnel-update { |
| type uint32; | | type uint32; |
| description | | description |
| "Time since the last tunnel update happened"; | | "Time since the last tunnel update happened"; |
| } | | } |
| leaf tunnel-color { | | leaf tunnel-color { |
| type uint32; | | type uint32; |
| description | | description |
| "Color corresponding to this SR tunnel"; | | "Color corresponding to this SR tunnel"; |
| } | | } |
| n | leaf has-tunnel-metric { | n | |
| type boolean; | | |
| description | | |
| "This SR-TE tunnel has an admin distance/metric"; | | |
| } | | |
| leaf tunnel-metric-ad { | | |
| type uint32; | | |
| description | | |
| "Metric admin distance corresponding to this SR | | |
| tunnel"; | | |
| } | | |
| leaf tunnel-metric-value { | | |
| type uint32; | | |
| description | | |
| "Metric value corresponding to this SR tunnel"; | | |
| } | | |
| leaf is-tunnel-color-only { | | leaf is-tunnel-color-only { |
| type boolean; | | type boolean; |
| description | | description |
| "Is a Color Only (Null Endpoint) tunnel"; | | "Is a Color Only (Null Endpoint) tunnel"; |
| } | | } |
| leaf tunnel-endpoint-afi { | | leaf tunnel-endpoint-afi { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "AFI of the Null Endpoint (IPv4/IPv6)"; | | "AFI of the Null Endpoint (IPv4/IPv6)"; |
| } | | } |
| leaf flags { | | leaf flags { |
| type uint32; | | type uint32; |
| description | | description |
| "SR Tunnel specific flags "; | | "SR Tunnel specific flags "; |
| } | | } |
| n | leaf haveu-srv6-bsid { | n | |
| type boolean; | | |
| description | | |
| "SRv6 BSID for tunnel present"; | | |
| } | | |
| leaf srv6u-bsid-address { | | |
| type Ipv6-address; | | |
| description | | |
| "SRv6 uBSID address value"; | | |
| } | | |
| leaf prefix-path-label-ignore { | | |
| type boolean; | | |
| description | | |
| "BGP steering over SR-Policy with | | |
| prefix-path-label ignore"; | | |
| } | | |
| leaf sr-policy-segment-list-type { | | |
| type Bgp-policy-sl; | | |
| description | | |
| "SR-Policy Segment-List type"; | | |
| } | | |
| } | | } |
| | | |
| grouping BGP-PREFIXTYPE { | | grouping BGP-PREFIXTYPE { |
| description | | description |
| "BGP PREFIXTYPE"; | | "BGP PREFIXTYPE"; |
| container prefix { | | container prefix { |
| description | | description |
| n | "The Prefix from whichto get the address"; | n | "Prefix"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| leaf prefix-length { | | leaf prefix-length { |
| type uint16; | | type uint16; |
| description | | description |
| n | "BGP prefix length of the route"; | n | "Prefix length"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-PATH { | | grouping BGP-PATH { |
| description | | description |
| "BGP Path"; | | "BGP Path"; |
| container bgp-prefix { | | container bgp-prefix { |
| description | | description |
| "BGP prefix"; | | "BGP prefix"; |
| uses BGP-PREFIXTYPE; | | uses BGP-PREFIXTYPE; |
| } | | } |
| container neighbor-address { | | container neighbor-address { |
| description | | description |
| n | "Neighbor address specified in BGP path"; | n | "Neighbor address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container next-hop { | | container next-hop { |
| description | | description |
| n | "BGP Next hop information"; | n | "Next hop"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container nh-tunnel { | | container nh-tunnel { |
| description | | description |
| n | "Next hop tunnel information"; | n | "NH tunnel information"; |
| uses BGP-TE-TUNNEL; | | uses BGP-TE-TUNNEL; |
| } | | } |
| container mdt-group-addr { | | container mdt-group-addr { |
| description | | description |
| "IPv4 MDT Group Address for the path"; | | "IPv4 MDT Group Address for the path"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container gw-addr { | | container gw-addr { |
| description | | description |
| "Path GW Address"; | | "Path GW Address"; |
| uses BGP-V4-V6; | | uses BGP-V4-V6; |
| } | | } |
| container nh-addr { | | container nh-addr { |
| description | | description |
| "Path next-hop Address"; | | "Path next-hop Address"; |
| uses BGP-V4-V6; | | uses BGP-V4-V6; |
| } | | } |
| container best-path-comp-winner { | | container best-path-comp-winner { |
| description | | description |
| "Neighbor address of the path which won best path | | "Neighbor address of the path which won best path |
| comparison"; | | comparison"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container mvpn-nbr-addr { | | container mvpn-nbr-addr { |
| description | | description |
| "Mvpn nbr Address for the path"; | | "Mvpn nbr Address for the path"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container mvpn-nexthop-addr { | | container mvpn-nexthop-addr { |
| description | | description |
| "Mvpn nexthop Address for the path"; | | "Mvpn nexthop Address for the path"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container vpn-nexthop-addr { | | container vpn-nexthop-addr { |
| description | | description |
| "Vpn nexthop Address for the path"; | | "Vpn nexthop Address for the path"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| n | container evpn-imet-pmsi-nexthop-addr { | n | |
| description | | |
| "EVPN IMET PMSI Originator Nexthop Address"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| leaf route-type { | | leaf route-type { |
| type Bgp-route1; | | type Bgp-route1; |
| description | | description |
| "Route Type of path"; | | "Route Type of path"; |
| } | | } |
| leaf is-path-valid { | | leaf is-path-valid { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if BGP path attributes are | n | "Path attributes are usable"; |
| usable"; | | |
| } | | } |
| leaf is-path-damped { | | leaf is-path-damped { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if Path suppressed due to | n | "Path suppressed due to dampening"; |
| dampening"; | | |
| } | | } |
| leaf is-path-history-held { | | leaf is-path-history-held { |
| type boolean; | | type boolean; |
| description | | description |
| "Path entry held to remember history"; | | "Path entry held to remember history"; |
| } | | } |
| leaf is-internal-path { | | leaf is-internal-path { |
| type boolean; | | type boolean; |
| description | | description |
| "Received over an internal link"; | | "Received over an internal link"; |
| } | | } |
| leaf is-best-path { | | leaf is-best-path { |
| type boolean; | | type boolean; |
| description | | description |
| "Best available path"; | | "Best available path"; |
| } | | } |
| leaf is-as-best { | | leaf is-as-best { |
| type boolean; | | type boolean; |
| description | | description |
| "Best available path within AS"; | | "Best available path within AS"; |
| } | | } |
| leaf is-spkr-as-best { | | leaf is-spkr-as-best { |
| type boolean; | | type boolean; |
| description | | description |
| "Best available path within AS in speaker"; | | "Best available path within AS in speaker"; |
| } | | } |
| leaf is-partial-best { | | leaf is-partial-best { |
| type boolean; | | type boolean; |
| description | | description |
| "Partial best path within distributed speaker"; | | "Partial best path within distributed speaker"; |
| } | | } |
| leaf is-aggregation-suppressed { | | leaf is-aggregation-suppressed { |
| type boolean; | | type boolean; |
| description | | description |
| "Path suppressed due to aggregation"; | | "Path suppressed due to aggregation"; |
| } | | } |
| leaf is-import-dampened { | | leaf is-import-dampened { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if BGP path net import is | n | |
| dampened"; | | "net import dampened"; |
| } | | } |
| leaf is-import-suspect { | | leaf is-import-suspect { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if BGP path net import is | n | |
| suspect"; | | "net import suspect"; |
| } | | } |
| leaf is-path-not-advertised { | | leaf is-path-not-advertised { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if path is not advertised to | n | "Not advertised to any peer"; |
| any peer"; | | |
| } | | } |
| leaf is-path-not-advertised-to-ebgp { | | leaf is-path-not-advertised-to-ebgp { |
| type boolean; | | type boolean; |
| description | | description |
| "Not advertised to EBGPs"; | | "Not advertised to EBGPs"; |
| } | | } |
| leaf is-path-advertised-local-as-only { | | leaf is-path-advertised-local-as-only { |
| type boolean; | | type boolean; |
| description | | description |
| "Not advertised outside local AS"; | | "Not advertised outside local AS"; |
| } | | } |
| leaf is-path-from-route-reflector { | | leaf is-path-from-route-reflector { |
| type boolean; | | type boolean; |
| description | | description |
| "Path received from route reflector"; | | "Path received from route reflector"; |
| } | | } |
| leaf is-path-received-only { | | leaf is-path-received-only { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if BGP Path is received only"; | n | "Path is received only"; |
| } | | } |
| leaf is-received-path-not-modified { | | leaf is-received-path-not-modified { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if received path is used | n | |
| without modification"; | | "Received path used without modification"; |
| } | | } |
| leaf is-path-locally-sourced { | | leaf is-path-locally-sourced { |
| type boolean; | | type boolean; |
| description | | description |
| "Path sourced locally"; | | "Path sourced locally"; |
| } | | } |
| leaf is-path-local-aggregate { | | leaf is-path-local-aggregate { |
| type boolean; | | type boolean; |
| description | | description |
| "Path is a locally created aggregate"; | | "Path is a locally created aggregate"; |
| } | | } |
| leaf is-path-from-network-command { | | leaf is-path-from-network-command { |
| type boolean; | | type boolean; |
| description | | description |
| "Path sourced by network command"; | | "Path sourced by network command"; |
| } | | } |
| leaf is-path-from-redistribute-command { | | leaf is-path-from-redistribute-command { |
| type boolean; | | type boolean; |
| description | | description |
| "Path sourced by redistribute command"; | | "Path sourced by redistribute command"; |
| } | | } |
| leaf is-path-imported { | | leaf is-path-imported { |
| type boolean; | | type boolean; |
| description | | description |
| "Path is imported"; | | "Path is imported"; |
| } | | } |
| leaf is-path-reoriginated { | | leaf is-path-reoriginated { |
| type boolean; | | type boolean; |
| description | | description |
| "Path is reoriginated"; | | "Path is reoriginated"; |
| } | | } |
| leaf is-path-reoriginated-stitching { | | leaf is-path-reoriginated-stitching { |
| type boolean; | | type boolean; |
| description | | description |
| "Path is reoriginated with stitching RTs"; | | "Path is reoriginated with stitching RTs"; |
| } | | } |
| leaf is-path-vpn-only { | | leaf is-path-vpn-only { |
| type boolean; | | type boolean; |
| description | | description |
| "Path is not in the vrf"; | | "Path is not in the vrf"; |
| } | | } |
| leaf is-path-from-confederation-peer { | | leaf is-path-from-confederation-peer { |
| type boolean; | | type boolean; |
| description | | description |
| "Path received from confederation peer"; | | "Path received from confederation peer"; |
| } | | } |
| leaf is-path-synced-with-igp { | | leaf is-path-synced-with-igp { |
| type boolean; | | type boolean; |
| description | | description |
| "Path synchronized with IGP"; | | "Path synchronized with IGP"; |
| } | | } |
| leaf is-path-multipath { | | leaf is-path-multipath { |
| type boolean; | | type boolean; |
| description | | description |
| "Path is one of multipath best routes"; | | "Path is one of multipath best routes"; |
| } | | } |
| leaf is-path-imp-candidate { | | leaf is-path-imp-candidate { |
| type boolean; | | type boolean; |
| description | | description |
| "Path is a candidate for multipath import"; | | "Path is a candidate for multipath import"; |
| } | | } |
| leaf is-path-stale { | | leaf is-path-stale { |
| type boolean; | | type boolean; |
| description | | description |
| "Stale routes learnt before neighbor restarts"; | | "Stale routes learnt before neighbor restarts"; |
| } | | } |
| leaf is-path-long-lived-stale { | | leaf is-path-long-lived-stale { |
| type boolean; | | type boolean; |
| description | | description |
| "Long lived stale routes learnt before neighbor | | "Long lived stale routes learnt before neighbor |
| restarts"; | | restarts"; |
| } | | } |
| leaf is-path-backup { | | leaf is-path-backup { |
| type boolean; | | type boolean; |
| description | | description |
| "Path is a backup path "; | | "Path is a backup path "; |
| } | | } |
| leaf is-path-backup-protect-multipath { | | leaf is-path-backup-protect-multipath { |
| type boolean; | | type boolean; |
| description | | description |
| "Path is a backup path to protect multipaths"; | | "Path is a backup path to protect multipaths"; |
| } | | } |
| leaf is-path-best-external { | | leaf is-path-best-external { |
| type boolean; | | type boolean; |
| description | | description |
| "Path is a best external path"; | | "Path is a best external path"; |
| } | | } |
| leaf is-path-additional-path { | | leaf is-path-additional-path { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate BGP Path is an additional-path"; | n | "Path is an additional-path"; |
| } | | } |
| leaf is-path-nexthop-discarded { | | leaf is-path-nexthop-discarded { |
| type boolean; | | type boolean; |
| description | | description |
| "Path is redirected to Null0"; | | "Path is redirected to Null0"; |
| } | | } |
| leaf has-local-net-label { | | leaf has-local-net-label { |
| type boolean; | | type boolean; |
| description | | description |
| "Path has local label"; | | "Path has local label"; |
| } | | } |
| leaf local-label { | | leaf local-label { |
| type uint32; | | type uint32; |
| description | | description |
| n | " BGP Path local label"; | n | "Path local label"; |
| } | | } |
| leaf igp-metric { | | leaf igp-metric { |
| type uint32; | | type uint32; |
| description | | description |
| "IGP metric to the gateway"; | | "IGP metric to the gateway"; |
| } | | } |
| leaf path-weight { | | leaf path-weight { |
| type uint16; | | type uint16; |
| description | | description |
| "Weight for the path"; | | "Weight for the path"; |
| } | | } |
| leaf neighbor-router-id { | | leaf neighbor-router-id { |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "Router ID of the neighbor for the path"; | | "Router ID of the neighbor for the path"; |
| } | | } |
| leaf has-mdt-group-addr { | | leaf has-mdt-group-addr { |
| type boolean; | | type boolean; |
| description | | description |
| "Path has MDT Group Address"; | | "Path has MDT Group Address"; |
| } | | } |
| leaf l2vpn-size { | | leaf l2vpn-size { |
| type uint32; | | type uint32; |
| description | | description |
| "Path block size"; | | "Path block size"; |
| } | | } |
| leaf l2vpn-evpn-esi { | | leaf l2vpn-evpn-esi { |
| type string; | | type string; |
| description | | description |
| "L2VPN EVPN ESI"; | | "L2VPN EVPN ESI"; |
| } | | } |
| leaf evpn-path-flags { | | leaf evpn-path-flags { |
| type uint32; | | type uint32; |
| description | | description |
| "L2VPN EVPN Path flags"; | | "L2VPN EVPN Path flags"; |
| } | | } |
| leaf has-gw-addr { | | leaf has-gw-addr { |
| type boolean; | | type boolean; |
| description | | description |
| "Path has GW Address"; | | "Path has GW Address"; |
| } | | } |
| leaf has-nh-addr { | | leaf has-nh-addr { |
| type boolean; | | type boolean; |
| description | | description |
| "Path has next-hop Address"; | | "Path has next-hop Address"; |
| } | | } |
| n | leaf nexthop-interface-handle { | n | |
| type uint32; | | |
| description | | |
| "Interface Handle of Nexthop"; | | |
| } | | |
| leaf has-second-label { | | leaf has-second-label { |
| type boolean; | | type boolean; |
| description | | description |
| "Path has second received label"; | | "Path has second received label"; |
| } | | } |
| leaf second-label { | | leaf second-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Path second received label"; | | "Path second received label"; |
| } | | } |
| leaf path-flap-count { | | leaf path-flap-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of times this route has flapped"; | | "Number of times this route has flapped"; |
| } | | } |
| leaf seconds-since-first-flap { | | leaf seconds-since-first-flap { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| n | "BGP damp info in seconds, since first route | n | "Seconds since route first flapped"; |
| flapped"; | | |
| } | | } |
| leaf time-to-unsuppress { | | leaf time-to-unsuppress { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Seconds until route is unsuppressed"; | | "Seconds until route is unsuppressed"; |
| } | | } |
| leaf dampen-penalty { | | leaf dampen-penalty { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP Dampening penalty"; | n | "Dampening penalty"; |
| } | | } |
| leaf halflife-time { | | leaf halflife-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Half-life time for the penalty"; | | "Half-life time for the penalty"; |
| } | | } |
| leaf suppress-penalty { | | leaf suppress-penalty { |
| type uint32; | | type uint32; |
| description | | description |
| "Value to start suppressing a route"; | | "Value to start suppressing a route"; |
| } | | } |
| leaf reuse-value { | | leaf reuse-value { |
| type uint32; | | type uint32; |
| description | | description |
| "Value to start reusing a route"; | | "Value to start reusing a route"; |
| } | | } |
| leaf maximum-suppress-time { | | leaf maximum-suppress-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Maximum duration to suppress a stable route"; | | "Maximum duration to suppress a stable route"; |
| } | | } |
| leaf best-path-comp-stage { | | leaf best-path-comp-stage { |
| type Bgp-bp-stage; | | type Bgp-bp-stage; |
| description | | description |
| "Stage where the path lost to the best path or | | "Stage where the path lost to the best path or |
| group best"; | | group best"; |
| } | | } |
| leaf best-path-id-comp-winner { | | leaf best-path-id-comp-winner { |
| type uint32; | | type uint32; |
| description | | description |
| "Path ID of the path which won best path | | "Path ID of the path which won best path |
| comparison"; | | comparison"; |
| } | | } |
| leaf path-flags { | | leaf path-flags { |
| type uint64; | | type uint64; |
| description | | description |
| "Flags associated with path"; | | "Flags associated with path"; |
| } | | } |
| n | leaf path-flags2 { | n | |
| type uint32; | | |
| description | | |
| "Flags2 associated with path"; | | |
| } | | |
| leaf path-import-flags { | | leaf path-import-flags { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Flags to indicate for import processing in BGP"; | n | "Path import flags"; |
| } | | } |
| leaf best-path-id { | | leaf best-path-id { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Best path ID; DEPRECATED BY LocalPathId"; | n | "Best path ID; DEPRECATED BYLocalPathId"; |
| } | | } |
| leaf local-path-id { | | leaf local-path-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Local path ID"; | | "Local path ID"; |
| } | | } |
| leaf rcvd-path-id { | | leaf rcvd-path-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Received path ID"; | | "Received path ID"; |
| } | | } |
| leaf path-table-version { | | leaf path-table-version { |
| n | type uint64; | n | type uint32; |
| description | | description |
| "Table version # for pelem"; | | "Table version # for pelem"; |
| } | | } |
| leaf advertisedto-pe { | | leaf advertisedto-pe { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Net could be advertised to PE peers"; | n | "Net could be advertised |
| | | to PE peers"; |
| } | | } |
| leaf rib-failed { | | leaf rib-failed { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Is net failed installed in RIB"; | n | "Is net failed installed |
| | | in RIB"; |
| } | | } |
| leaf sn-rpki-origin-as-validity { | | leaf sn-rpki-origin-as-validity { |
| type uint8; | | type uint8; |
| description | | description |
| "RPKI origin validation state"; | | "RPKI origin validation state"; |
| } | | } |
| leaf show-rpki-origin-as-validity { | | leaf show-rpki-origin-as-validity { |
| type boolean; | | type boolean; |
| description | | description |
| "Display validity state ?"; | | "Display validity state ?"; |
| } | | } |
| leaf ibgp-signaled-validity { | | leaf ibgp-signaled-validity { |
| type boolean; | | type boolean; |
| description | | description |
| "IBGP signalled validation"; | | "IBGP signalled validation"; |
| } | | } |
| leaf rpki-origin-as-validation-disabled { | | leaf rpki-origin-as-validation-disabled { |
| type boolean; | | type boolean; |
| description | | description |
| "RPKI originAS V. Disabled"; | | "RPKI originAS V. Disabled"; |
| } | | } |
| leaf accept-own-path { | | leaf accept-own-path { |
| type boolean; | | type boolean; |
| description | | description |
| "Accept Own"; | | "Accept Own"; |
| } | | } |
| leaf accept-own-self-originated-path { | | leaf accept-own-self-originated-path { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if BGP path is Accept-Own | n | "Accept-Own self-originated"; |
| community and self-originated"; | | |
| } | | } |
| leaf aigp-metric { | | leaf aigp-metric { |
| type uint64; | | type uint64; |
| description | | description |
| "Total AIGP metric"; | | "Total AIGP metric"; |
| } | | } |
| leaf mvpn-sfs-path { | | leaf mvpn-sfs-path { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if MVPN single forwarder PE | n | "Is MVPN single forwarder PE path"; |
| path"; | | |
| } | | } |
| leaf fspec-invalid-path { | | leaf fspec-invalid-path { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if path is invalidated by | n | "Is Fspec invalid path"; |
| flow-spec rules"; | | |
| } | | } |
| leaf has-mvpn-nbr-addr { | | leaf has-mvpn-nbr-addr { |
| type boolean; | | type boolean; |
| description | | description |
| "Path has Mvpn nbr Address"; | | "Path has Mvpn nbr Address"; |
| } | | } |
| leaf has-mvpn-nexthop-addr { | | leaf has-mvpn-nexthop-addr { |
| type boolean; | | type boolean; |
| description | | description |
| "Path has MVPN nexthop Address"; | | "Path has MVPN nexthop Address"; |
| } | | } |
| leaf has-mvpn-pmsi { | | leaf has-mvpn-pmsi { |
| type boolean; | | type boolean; |
| description | | description |
| "Path has MVPN PMSI feedback"; | | "Path has MVPN PMSI feedback"; |
| } | | } |
| leaf mvpn-pmsi-type { | | leaf mvpn-pmsi-type { |
| type uint16; | | type uint16; |
| description | | description |
| "Mvpn PMSI Type"; | | "Mvpn PMSI Type"; |
| } | | } |
| leaf mvpn-pmsi-flags { | | leaf mvpn-pmsi-flags { |
| type uint8; | | type uint8; |
| description | | description |
| "Mvpn PMSI Value"; | | "Mvpn PMSI Value"; |
| } | | } |
| leaf mvpn-pmsi-label { | | leaf mvpn-pmsi-label { |
| type uint32; | | type uint32; |
| description | | description |
| "Mvpn PMSI label"; | | "Mvpn PMSI label"; |
| } | | } |
| leaf has-mvpn-extcomm { | | leaf has-mvpn-extcomm { |
| type boolean; | | type boolean; |
| description | | description |
| "Path has MVPN EXTCOMM feedback"; | | "Path has MVPN EXTCOMM feedback"; |
| } | | } |
| leaf mvpn-path-flags { | | leaf mvpn-path-flags { |
| type uint16; | | type uint16; |
| description | | description |
| n | "Multicast Virtual Private Networks specific path | n | "Mvpn path flags"; |
| info"; | | |
| } | | } |
| leaf local-nh { | | leaf local-nh { |
| type boolean; | | type boolean; |
| description | | description |
| "Path has local nexthop"; | | "Path has local nexthop"; |
| } | | } |
| leaf rt-set-limit-enabled { | | leaf rt-set-limit-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Path subject to RT-set net limit"; | | "Path subject to RT-set net limit"; |
| } | | } |
| leaf path-rt-set-id { | | leaf path-rt-set-id { |
| type uint32; | | type uint32; |
| description | | description |
| "RT-set id of the path"; | | "RT-set id of the path"; |
| } | | } |
| leaf path-rt-set-route-count { | | leaf path-rt-set-route-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Count in RT-set"; | | "Count in RT-set"; |
| } | | } |
| leaf is-path-af-install-eligible { | | leaf is-path-af-install-eligible { |
| type boolean; | | type boolean; |
| description | | description |
| "Path can be installed in AF RIB"; | | "Path can be installed in AF RIB"; |
| } | | } |
| leaf is-permanent-path { | | leaf is-permanent-path { |
| type boolean; | | type boolean; |
| description | | description |
| "Path is of type Permanent path"; | | "Path is of type Permanent path"; |
| } | | } |
| leaf graceful-shutdown { | | leaf graceful-shutdown { |
| type boolean; | | type boolean; |
| description | | description |
| "Marked for graceful shutdown"; | | "Marked for graceful shutdown"; |
| } | | } |
| leaf labeled-unicast-safi-path { | | leaf labeled-unicast-safi-path { |
| type boolean; | | type boolean; |
| description | | description |
| "Path was learnt by labeled-unicast SAFI"; | | "Path was learnt by labeled-unicast SAFI"; |
| } | | } |
| leaf has-vpn-nexthop-addr { | | leaf has-vpn-nexthop-addr { |
| type boolean; | | type boolean; |
| description | | description |
| "Path has VPN nexthop Address"; | | "Path has VPN nexthop Address"; |
| } | | } |
| leaf is-orig-src-rd-present { | | leaf is-orig-src-rd-present { |
| type boolean; | | type boolean; |
| description | | description |
| "Original Source RD present"; | | "Original Source RD present"; |
| } | | } |
| leaf af-name { | | leaf af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Original Source Address family identifier"; | | "Original Source Address family identifier"; |
| } | | } |
| leaf route-distinguisher { | | leaf route-distinguisher { |
| type xr:Route-dist; | | type xr:Route-dist; |
| description | | description |
| "Original Source Route Distinguisher"; | | "Original Source Route Distinguisher"; |
| } | | } |
| leaf mac-ip-present { | | leaf mac-ip-present { |
| type boolean; | | type boolean; |
| description | | description |
| "Mac IP Present present"; | | "Mac IP Present present"; |
| } | | } |
| leaf mac-ip { | | leaf mac-ip { |
| type yang:mac-address; | | type yang:mac-address; |
| description | | description |
| "Mac associated with IP"; | | "Mac associated with IP"; |
| } | | } |
| leaf ether-tag-id { | | leaf ether-tag-id { |
| type uint32; | | type uint32; |
| description | | description |
| "Ethernet Tag Id"; | | "Ethernet Tag Id"; |
| n | } | n | |
| leaf igmp-flags-present { | | |
| type boolean; | | |
| description | | |
| "EVPN IGMP Flags Present"; | | |
| } | | |
| leaf igmp-flags { | | |
| type uint8; | | |
| description | | |
| "EVPN IGMP Flags"; | | |
| } | | |
| leaf has-srv6-sid-allocated { | | |
| type boolean; | | |
| description | | |
| "Net has SRv6 SID allocated"; | | |
| } | | |
| leaf srv6-sid-address { | | |
| type Ipv6-address; | | |
| description | | |
| "SRv6 SID address value"; | | |
| } | | |
| leaf srv6-sid-address-len { | | |
| type uint32; | | |
| description | | |
| "SRv6 SID address Length"; | | |
| } | | |
| leaf srv6-sid-alloc-mode { | | |
| type uint32; | | |
| description | | |
| "SID alloc mode of SRv6"; | | |
| } | | |
| leaf srv6-locator { | | |
| type string; | | |
| description | | |
| "SRv6 Locator Name"; | | |
| } | | |
| leaf evpn-imet-pmsi-originator-present { | | |
| type boolean; | | |
| description | | |
| "EVPN IMET PMSI Originator Nexthop is present"; | | |
| } | | |
| leaf evpn-imet-pmsi-nexthop-reachable { | | |
| type boolean; | | |
| description | | |
| "Reachability for PMSI Originator nexthop"; | | |
| } | | |
| leaf path-count { | | |
| type uint32; | | |
| description | | |
| "Number of paths for net"; | | |
| } | | |
| leaf rib-delay { | | |
| type boolean; | | |
| description | | |
| "RIB Download Delay Applicable"; | | |
| } | | } |
| list rcvd-label { | | list rcvd-label { |
| description | | description |
| "Path received label stack"; | | "Path received label stack"; |
| leaf entry { | | leaf entry { |
| type uint32; | | type uint32; |
| description | | description |
| "Path received label stack"; | | "Path received label stack"; |
| } | | } |
| } | | } |
| list l2vpn-circuit-status-value { | | list l2vpn-circuit-status-value { |
| description | | description |
| "L2VPN Circuit Status Value"; | | "L2VPN Circuit Status Value"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "L2VPN Circuit Status Value"; | | "L2VPN Circuit Status Value"; |
| } | | } |
| } | | } |
| list mvpn-pmsi-value { | | list mvpn-pmsi-value { |
| description | | description |
| "Mvpn PMSI Value"; | | "Mvpn PMSI Value"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "Mvpn PMSI Value"; | | "Mvpn PMSI Value"; |
| } | | } |
| } | | } |
| list extended-community { | | list extended-community { |
| description | | description |
| "Mvpn Extended community attribute"; | | "Mvpn Extended community attribute"; |
| leaf entry { | | leaf entry { |
| type uint8; | | type uint8; |
| description | | description |
| "Mvpn Extended community attribute"; | | "Mvpn Extended community attribute"; |
| } | | } |
| } | | } |
| list local-peers-advertised-to { | | list local-peers-advertised-to { |
| description | | description |
| "Local peers that this prefix has been advertised | | "Local peers that this prefix has been advertised |
| to"; | | to"; |
| uses BGP-ADVINFO-TYPE; | | uses BGP-ADVINFO-TYPE; |
| } | | } |
| list pe-peers-advertised-to { | | list pe-peers-advertised-to { |
| description | | description |
| "PE peers that this prefix has been advertised to"; | | "PE peers that this prefix has been advertised to"; |
| uses BGP-ADVINFO-TYPE; | | uses BGP-ADVINFO-TYPE; |
| } | | } |
| n | list best-path-orrbitfield { | n | list best-path-orr-bitfield { |
| description | | description |
| "ORR Best path Bitfields"; | | "ORR Best path Bitfields"; |
| uses BGP-ADVINFO-TYPE; | | uses BGP-ADVINFO-TYPE; |
| } | | } |
| n | list add-path-orrbitfield { | n | list add-path-orr-bitfield { |
| description | | description |
| "ORR Add path Bitfields"; | | "ORR Add path Bitfields"; |
| uses BGP-ADVINFO-TYPE; | | uses BGP-ADVINFO-TYPE; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-PATH-ADV-BAG { | | grouping BGP-PATH-ADV-BAG { |
| description | | description |
| "BGP path with advertised attributes information"; | | "BGP path with advertised attributes information"; |
| container neighbor-address-xr { | | container neighbor-address-xr { |
| description | | description |
| "Neighbor Address"; | | "Neighbor Address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container path-info-after-policy-in { | | container path-info-after-policy-in { |
| description | | description |
| "Path information after inbound policy"; | | "Path information after inbound policy"; |
| uses BGP-PATH; | | uses BGP-PATH; |
| } | | } |
| container path-info-after-policy-out { | | container path-info-after-policy-out { |
| description | | description |
| "Path information after outbound policy"; | | "Path information after outbound policy"; |
| uses BGP-PATH; | | uses BGP-PATH; |
| } | | } |
| container attributes-after-policy-in { | | container attributes-after-policy-in { |
| description | | description |
| "Attributes after inbound policy"; | | "Attributes after inbound policy"; |
| uses BGP-ATTR; | | uses BGP-ATTR; |
| } | | } |
| container attributes-after-policy-out { | | container attributes-after-policy-out { |
| description | | description |
| "Attributes after outbound policy"; | | "Attributes after outbound policy"; |
| uses BGP-ATTR; | | uses BGP-ATTR; |
| } | | } |
| leaf no-path { | | leaf no-path { |
| type boolean; | | type boolean; |
| description | | description |
| "No path exists All 'sp_path_in' fields except | | "No path exists All 'sp_path_in' fields except |
| 'sp_path_in->bag_prefix' are invalid. All | | 'sp_path_in->bag_prefix' are invalid. All |
| 'sp_path_out' fields are invalid."; | | 'sp_path_out' fields are invalid."; |
| } | | } |
| leaf af-name { | | leaf af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Address family identifier"; | | "Address family identifier"; |
| } | | } |
| leaf route-distinguisher { | | leaf route-distinguisher { |
| type xr:Route-dist; | | type xr:Route-dist; |
| description | | description |
| n | "BGP path with advertised Route Distinguisher"; | n | "Route Distinguisher"; |
| } | | } |
| leaf source-route-distinguisher { | | leaf source-route-distinguisher { |
| type xr:Route-dist; | | type xr:Route-dist; |
| description | | description |
| n | "BGP path advertised Source Route Distinguisher"; | n | "Source Route Distinguisher"; |
| } | | } |
| leaf vrf-name { | | leaf vrf-name { |
| type string; | | type string; |
| description | | description |
| "Name of the VRF"; | | "Name of the VRF"; |
| n | } | n | |
| } | | |
| | | |
| grouping BGP-RNH-ENTRY-INFO { | | |
| description | | |
| "BGP RNH ENTRY INFO"; | | |
| leaf lrnh-type { | | |
| type uint16; | | |
| description | | |
| "RNH Type"; | | |
| } | | |
| leaf lrnh-table { | | |
| type uint32; | | |
| description | | |
| "RNH Table ID"; | | |
| } | | |
| leaf lrnhvni { | | |
| type uint32; | | |
| description | | |
| "RNH VNI"; | | |
| } | | |
| leaf lrnh-addr { | | |
| type inet:ipv4-address; | | |
| description | | |
| "RNH Address"; | | |
| } | | |
| leaf lrnh-mac { | | |
| type Mac-address; | | |
| description | | |
| "RNH MAC Address"; | | |
| } | | |
| leaf frnh-as { | | |
| type uint8; | | |
| description | | |
| "RNH Flags"; | | |
| } | | |
| leaf rrnh-as { | | |
| type uint32; | | |
| description | | |
| "RNH Refcount"; | | |
| } | | |
| leaf lrnhul-table { | | |
| type uint32; | | |
| description | | |
| "RNH Underlay Table ID"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-L2VPN-EVPN-ESI { | | |
| description | | |
| "BGP L2VPN EVPN ESI"; | | |
| leaf esi { | | |
| type yang:hex-string; | | |
| description | | |
| "esi"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-LRNH-ENTRY-INFO { | | |
| description | | |
| "BGP LRNH ENTRY INFO"; | | |
| container local-rnhesi { | | |
| description | | |
| "Local RNH ESI"; | | |
| uses BGP-L2VPN-EVPN-ESI; | | |
| } | | |
| leaf lrnh-present { | | |
| type boolean; | | |
| description | | |
| "RNH present boolean"; | | |
| } | | |
| leaf lrnh-type { | | |
| type uint16; | | |
| description | | |
| "RNH Type"; | | |
| } | | |
| leaf lrnhvni { | | |
| type uint32; | | |
| description | | |
| "RNH VNI"; | | |
| } | | |
| leaf lrnh-addr { | | |
| type inet:ipv4-address; | | |
| description | | |
| "RNH Address"; | | |
| } | | |
| leaf lrnhv6-addr { | | |
| type inet:ipv6-address; | | |
| description | | |
| "RNH IPv6 Address"; | | |
| } | | |
| leaf lrnh-mac { | | |
| type Mac-address; | | |
| description | | |
| "RNH MAC Address"; | | |
| } | | |
| leaf lrnhul-table { | | |
| type uint32; | | |
| description | | |
| "RNH Underlay Table ID"; | | |
| } | | |
| leaf lrnh-nve-id { | | |
| type uint32; | | |
| description | | |
| "NVE ID"; | | |
| } | | |
| leaf lrnh-nve-ifh { | | |
| type xr:Interface-name; | | |
| description | | |
| "NVE IFH"; | | |
| } | | |
| leaf lrnh-tunnel-type { | | |
| type uint32; | | |
| description | | |
| "Tunnel Type"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-RNH-BAG { | | |
| description | | |
| "BGP RNH"; | | |
| leaf lrnh-table { | | |
| type uint32; | | |
| description | | |
| "RNH Table ID"; | | |
| } | | |
| list local-rnh-entry { | | |
| max-elements "2"; | | |
| description | | |
| "Local RNH Entries"; | | |
| uses BGP-LRNH-ENTRY-INFO; | | |
| } | | |
| list rnh-entry-info { | | |
| description | | |
| "List of Dependency Tables "; | | |
| uses BGP-RNH-ENTRY-INFO; | | |
| } | | } |
| } | | } |
| | | |
| grouping BGP-EDM-RPKI-REFRESH-ENTRY { | | grouping BGP-EDM-RPKI-REFRESH-ENTRY { |
| description | | description |
| "BGP EDM RPKI REFRESH ENTRY"; | | "BGP EDM RPKI REFRESH ENTRY"; |
| leaf af-name { | | leaf af-name { |
| type Bgp-rpki-af; | | type Bgp-rpki-af; |
| description | | description |
| "Address Family"; | | "Address Family"; |
| } | | } |
| leaf neighbor { | | leaf neighbor { |
| type string; | | type string; |
| description | | description |
| "BGP neighbor"; | | "BGP neighbor"; |
| } | | } |
| leaf policy { | | leaf policy { |
| type string; | | type string; |
| description | | description |
| "Route Policy"; | | "Route Policy"; |
| } | | } |
| leaf paths { | | leaf paths { |
| type uint32; | | type uint32; |
| description | | description |
| "Number of BGP paths modified or dropped"; | | "Number of BGP paths modified or dropped"; |
| } | | } |
| leaf drop { | | leaf drop { |
| type boolean; | | type boolean; |
| description | | description |
| "BGP paths were dropped"; | | "BGP paths were dropped"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-RPKI-REFRESH-LIST-BAG { | | grouping BGP-RPKI-REFRESH-LIST-BAG { |
| description | | description |
| "BGP RPKI REFRESH LIST BAG"; | | "BGP RPKI REFRESH LIST BAG"; |
| list refresh-entry { | | list refresh-entry { |
| description | | description |
| "Array of refresh entries"; | | "Array of refresh entries"; |
| uses BGP-EDM-RPKI-REFRESH-ENTRY; | | uses BGP-EDM-RPKI-REFRESH-ENTRY; |
| } | | } |
| } | | } |
| | | |
| n | grouping BGP-DRYRUN-POLICY-STATS-NBR-BAG { | n | |
| description | | |
| "BGP dryrun policy neighbor statistics bag"; | | |
| container neighbor-address { | | |
| description | | |
| "Neighbor address"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| leaf prefix-modified-count { | | |
| type uint32; | | |
| description | | |
| "Number of accepted modified prefixes"; | | |
| } | | |
| leaf prefix-accepted-count { | | |
| type uint32; | | |
| description | | |
| "Number of accepted unmodified prefixes"; | | |
| } | | |
| leaf prefix-denied-count { | | |
| type uint32; | | |
| description | | |
| "Number of denied prefixes"; | | |
| } | | |
| leaf current-policy-prefix-accepted-modified { | | |
| type uint64; | | |
| description | | |
| "Number of prefixes accepted modifed by | | |
| soft-reconfigfrom this BGP neighbor"; | | |
| } | | |
| leaf current-policy-denied { | | |
| type uint64; | | |
| description | | |
| "Number of prefixes exactly denied (non | | |
| cumulative)"; | | |
| } | | |
| leaf current-policy-accepted { | | |
| type uint64; | | |
| description | | |
| "Number of prefixes acceptedfrom this BGP | | |
| neighbor"; | | |
| } | | |
| leaf path-memory { | | |
| type uint64; | | |
| units "byte"; | | |
| description | | |
| "Memory in bytes used by the smallest pathin the | | |
| given AFI for a single path"; | | |
| } | | |
| leaf path-memory-count { | | |
| type uint64; | | |
| units "byte"; | | |
| description | | |
| "Total memory in bytes used by the smallest | | |
| pathin the given AFI"; | | |
| } | | |
| leaf paths-nbr-count { | | |
| type uint32; | | |
| description | | |
| "Paths evaluated for this neighbor"; | | |
| } | | |
| leaf remote-as { | | |
| type uint32; | | |
| description | | |
| "Remote Autonomous System number"; | | |
| } | | |
| leaf route-policy-in { | | |
| type string; | | |
| description | | |
| "Incoming route policy name"; | | |
| } | | |
| leaf inuse-policy { | | |
| type Bgp-dryrun-inuse-policy-state; | | |
| description | | |
| "Inuse Policy presence"; | | |
| } | | |
| leaf soft-reconfig { | | |
| type Bgp-dryrun-softreconfig-state; | | |
| description | | |
| "Soft reconfig configuration presence"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-DRYRUN-POLICY-STATS-AFI { | | |
| description | | |
| "BGP dryrun policy afi statistics bag"; | | |
| leaf af-name { | | |
| type Bgp-afi; | | |
| description | | |
| "Address family identifier"; | | |
| } | | |
| leaf number-of-networks { | | |
| type uint32; | | |
| description | | |
| "Total Number of networks count"; | | |
| } | | |
| leaf path-afi-count { | | |
| type uint32; | | |
| description | | |
| "Total number of paths count per AFI"; | | |
| } | | |
| leaf policy-exists { | | |
| type Bgp-dryrun-policy-error; | | |
| description | | |
| "Policy Config Error"; | | |
| } | | |
| leaf elapsed-duration { | | |
| type uint64; | | |
| description | | |
| "Dryrun total elapsed duration in ms"; | | |
| } | | |
| leaf busy-retry-later { | | |
| type boolean; | | |
| description | | |
| "Dryrun currently executing for an other policy, | | |
| retry later"; | | |
| } | | |
| leaf request-complete { | | |
| type uint32; | | |
| description | | |
| "Dryrun request is complete"; | | |
| } | | |
| leaf num-networks-walked { | | |
| type uint32; | | |
| description | | |
| "Total Number of networks walked so far"; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-DRYRUN-POLICY-STATS-NEIGHBOR-GROUPS-BAG { | | |
| description | | |
| "BGP dryrun policy statistics bag"; | | |
| container afi-stats { | | |
| description | | |
| "BGP dryrun afi statistics"; | | |
| uses BGP-DRYRUN-POLICY-STATS-AFI; | | |
| } | | |
| list nbr-stat { | | |
| description | | |
| "BGP dryrun neighbor statistics"; | | |
| uses BGP-DRYRUN-POLICY-STATS-NBR-BAG; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-UPDERR-VRF-BAG { | | grouping BGP-UPDERR-VRF-BAG { |
| description | | description |
| "BGP Update error-handling VRF information"; | | "BGP Update error-handling VRF information"; |
| container last-update-malformed-timestamp { | | container last-update-malformed-timestamp { |
| description | | description |
| "Last malformed messages received time: time | | "Last malformed messages received time: time |
| elapsed since 00:00:00 UTC, January 1, 1970"; | | elapsed since 00:00:00 UTC, January 1, 1970"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| leaf update-vrf-name { | | leaf update-vrf-name { |
| type string; | | type string; |
| description | | description |
| "VRF Name"; | | "VRF Name"; |
| } | | } |
| leaf update-malformed-message-count { | | leaf update-malformed-message-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP virtual routing & forwarding malformed | n | |
| messages count"; | | "Malformed messages count"; |
| } | | } |
| leaf update-malformed-neighbor-count { | | leaf update-malformed-neighbor-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Count of neighbors that received malformed | | "Count of neighbors that received malformed |
| messages"; | | messages"; |
| } | | } |
| leaf last-update-malformed-age { | | leaf last-update-malformed-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last malformed messages received | | "Time since last malformed messages received |
| event (in seconds)"; | | event (in seconds)"; |
| n | } | n | |
| } | | |
| | | |
| grouping NBR-VER-RATE-DETAIL { | | |
| description | | |
| "NBR VER RATE DETAIL"; | | |
| container version-bump-count-interval-start { | | |
| description | | |
| "Start time of the stat collection interval"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| container version-bump-count-interval-end { | | |
| description | | |
| "End time of the stat collection interval"; | | |
| uses BGP-TIMESPEC; | | |
| } | | |
| leaf interval-info { | | |
| type Bgp-vr-int; | | |
| description | | |
| "Stat collection interval identifier"; | | |
| } | | |
| list version-bump-count-interval { | | |
| description | | |
| "Version bumps per event in the stat collection | | |
| interval"; | | |
| uses NBR-INT-BUMPCOUNT; | | |
| } | | |
| } | | |
| | | |
| grouping NBR-INT-BUMPCOUNT { | | |
| description | | |
| "NBR INT BUMPCOUNT"; | | |
| leaf bump-count-event { | | |
| type Nbr-vr-bumpcount-event; | | |
| description | | |
| "Event contributing to version bumps"; | | |
| } | | |
| leaf version-bump-count { | | |
| type uint32; | | |
| description | | |
| "Rolling average of version bumps in this stat | | |
| collection interval"; | | |
| } | | |
| } | | |
| | | |
| grouping NBR-VER-RATE { | | |
| description | | |
| "NBR VER RATE"; | | |
| leaf interval-info { | | |
| type Bgp-vr-int; | | |
| description | | |
| "Stat collection interval identifier"; | | |
| } | | |
| list version-bump-count-interval { | | |
| description | | |
| "Version bumps per event in the stat collection | | |
| interval"; | | |
| uses NBR-INT-BUMPCOUNT; | | |
| } | | |
| } | | |
| | | |
| grouping NBR-TOTAL-BUMPS { | | |
| description | | |
| "NBR TOTAL BUMPS"; | | |
| leaf bump-event-count { | | |
| type Nbr-vr-bumpcount-event; | | |
| description | | |
| "Event contributing to version bumps"; | | |
| } | | |
| leaf version-bumps-count { | | |
| type uint64; | | |
| description | | |
| "Total number of version bumps"; | | |
| } | | |
| } | | |
| | | |
| grouping VERSION-RATE-AFI { | | |
| description | | |
| "BGP neighbor brief version rate AFI level | | |
| information"; | | |
| leaf af-name { | | |
| type Bgp-afi; | | |
| description | | |
| "Address family identifier"; | | |
| } | | |
| list version-bump-count { | | |
| description | | |
| "Total version bumps per event"; | | |
| uses NBR-TOTAL-BUMPS; | | |
| } | | |
| list version-rate-stat { | | |
| max-elements "4"; | | |
| description | | |
| "Version bump stats per event per interval"; | | |
| uses NBR-VER-RATE; | | |
| } | | |
| } | | |
| | | |
| grouping BGP-NBR-BRIEF-BAG { | | |
| description | | |
| "BGP Neighbor brief Information"; | | |
| container connection-local-address { | | |
| description | | |
| "Local address for the connection"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| container connection-remote-address { | | |
| description | | |
| "Remote address for the connection"; | | |
| uses BGP-ADDRTYPE; | | |
| } | | |
| leaf speaker-id { | | |
| type uint8; | | |
| description | | |
| "Speaker this neighbor is allocated to"; | | |
| } | | |
| leaf description { | | |
| type string; | | |
| description | | |
| "BGP neighbor brief description"; | | |
| } | | |
| leaf local-as { | | |
| type uint32; | | |
| description | | |
| "Local AS number"; | | |
| } | | |
| leaf remote-as { | | |
| type uint32; | | |
| description | | |
| "Remote AS number"; | | |
| } | | |
| leaf messages-sent { | | |
| type uint32; | | |
| description | | |
| "Number of messages sent"; | | |
| } | | |
| leaf messages-queued-in { | | |
| type uint32; | | |
| description | | |
| "No. of msgs on receive queue"; | | |
| } | | |
| leaf messages-queued-out { | | |
| type uint32; | | |
| description | | |
| "No. of messages on send queue"; | | |
| } | | |
| leaf connection-state { | | |
| type Bgp-conn-state; | | |
| description | | |
| "State of connection"; | | |
| } | | |
| leaf is-local-address-configured { | | |
| type boolean; | | |
| description | | |
| "Local address configured for the neighbor | | |
| connection"; | | |
| } | | |
| leaf vrf-name { | | |
| type string; | | |
| description | | |
| "Name of the VRF"; | | |
| } | | |
| leaf nsr-enabled { | | |
| type boolean; | | |
| description | | |
| "Neighbor supports NSR"; | | |
| } | | |
| leaf nsr-state { | | |
| type Bgp-sync-nbr-nsr-state; | | |
| description | | |
| "NSR state"; | | |
| } | | |
| leaf postit-pending { | | |
| type boolean; | | |
| description | | |
| "Nbr has postits pending"; | | |
| } | | |
| leaf connection-established-time { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Time (in secs) that the connection has been | | |
| established"; | | |
| } | | |
| leaf bmp-server-id { | | |
| type int32; | | |
| description | | |
| "BMP Server id"; | | |
| } | | |
| list neighbor-version { | | |
| max-elements "25"; | | |
| description | | |
| "BGP neighbor version for alladdress-families"; | | |
| leaf entry { | | |
| type uint64; | | |
| description | | |
| "BGP neighbor version for alladdress-families"; | | |
| } | | |
| } | | |
| list af-data { | | |
| max-elements "25"; | | |
| description | | |
| "Version rate data at the per address family | | |
| level"; | | |
| uses VERSION-RATE-AFI; | | |
| } | | |
| list version-bump-count { | | |
| description | | |
| "Total version bumps per event"; | | |
| uses NBR-TOTAL-BUMPS; | | |
| } | | |
| list version-rate-stat { | | |
| max-elements "4"; | | |
| description | | |
| "Per interval stats"; | | |
| uses NBR-VER-RATE-DETAIL; | | |
| } | | } |
| } | | } |
| | | |
| grouping BGP-TIMESPEC { | | grouping BGP-TIMESPEC { |
| description | | description |
| "BGP TIMESPEC"; | | "BGP TIMESPEC"; |
| leaf seconds { | | leaf seconds { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Seconds part of time value"; | | "Seconds part of time value"; |
| } | | } |
| leaf nanoseconds { | | leaf nanoseconds { |
| type uint32; | | type uint32; |
| units "nanosecond"; | | units "nanosecond"; |
| description | | description |
| "Nanoseconds part of time value"; | | "Nanoseconds part of time value"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPDGEN-STATS-BAG { | | grouping BGP-UPDGEN-STATS-BAG { |
| description | | description |
| "BGP Update generation common statistics | | "BGP Update generation common statistics |
| information"; | | information"; |
| container last-update-discard-timestamp { | | container last-update-discard-timestamp { |
| description | | description |
| "Last Discarded time"; | | "Last Discarded time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-update-cleared-timestamp { | | container last-update-cleared-timestamp { |
| description | | description |
| "Last Cleared time"; | | "Last Cleared time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-update-throttle-timestamp { | | container last-update-throttle-timestamp { |
| description | | description |
| "Last Throttled time"; | | "Last Throttled time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-update-recovery-timestamp { | | container last-update-recovery-timestamp { |
| description | | description |
| "Last Recovery time"; | | "Last Recovery time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| container last-update-memory-allocation-fail-timestamp { | | container last-update-memory-allocation-fail-timestamp { |
| description | | description |
| "Memory allocation failure time"; | | "Memory allocation failure time"; |
| uses BGP-TIMESPEC; | | uses BGP-TIMESPEC; |
| } | | } |
| leaf update-out-queue-messages-high { | | leaf update-out-queue-messages-high { |
| type uint32; | | type uint32; |
| description | | description |
| "OutQueue High Messages"; | | "OutQueue High Messages"; |
| } | | } |
| leaf update-out-queue-messages-cumulative { | | leaf update-out-queue-messages-cumulative { |
| type uint32; | | type uint32; |
| description | | description |
| "OutQueue Cumulative Messages"; | | "OutQueue Cumulative Messages"; |
| } | | } |
| leaf update-out-queue-messages-discarded { | | leaf update-out-queue-messages-discarded { |
| type uint32; | | type uint32; |
| description | | description |
| "OutQueue Discarded Messages"; | | "OutQueue Discarded Messages"; |
| } | | } |
| leaf update-out-queue-messages-cleared { | | leaf update-out-queue-messages-cleared { |
| type uint32; | | type uint32; |
| description | | description |
| "OutQueue Cleared Messages"; | | "OutQueue Cleared Messages"; |
| } | | } |
| leaf update-out-queue-size-high { | | leaf update-out-queue-size-high { |
| type uint32; | | type uint32; |
| description | | description |
| "OutQueue Hi Size"; | | "OutQueue Hi Size"; |
| } | | } |
| leaf update-out-queue-size-cumulative { | | leaf update-out-queue-size-cumulative { |
| type uint64; | | type uint64; |
| description | | description |
| "OutQueue Cumulative Size"; | | "OutQueue Cumulative Size"; |
| } | | } |
| leaf update-out-queue-size-discarded { | | leaf update-out-queue-size-discarded { |
| type uint64; | | type uint64; |
| description | | description |
| "OutQueue Discarded Size"; | | "OutQueue Discarded Size"; |
| } | | } |
| leaf update-out-queue-size-cleared { | | leaf update-out-queue-size-cleared { |
| type uint64; | | type uint64; |
| description | | description |
| "OutQueue Cleared Size"; | | "OutQueue Cleared Size"; |
| } | | } |
| leaf last-update-discard-age { | | leaf last-update-discard-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last Discard event (in seconds)"; | | "Time since last Discard event (in seconds)"; |
| } | | } |
| leaf last-update-cleard-age { | | leaf last-update-cleard-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last Clear event (in seconds)"; | | "Time since last Clear event (in seconds)"; |
| } | | } |
| leaf update-throttle-count { | | leaf update-throttle-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Throttle Count"; | | "Throttle Count"; |
| } | | } |
| leaf last-update-throttle-age { | | leaf last-update-throttle-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last Throttle event (in seconds)"; | | "Time since last Throttle event (in seconds)"; |
| } | | } |
| leaf update-recovery-count { | | leaf update-recovery-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Recovery Count"; | | "Recovery Count"; |
| } | | } |
| leaf last-update-recovery-age { | | leaf last-update-recovery-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last Recovery event (in seconds)"; | | "Time since last Recovery event (in seconds)"; |
| } | | } |
| leaf update-memory-allocation-fail-count { | | leaf update-memory-allocation-fail-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Number of times there was failure when | n | "Memory allocation failure count"; |
| allocatingmemory for BGP update generation"; | | |
| } | | } |
| leaf last-update-memory-allocation-fail-age { | | leaf last-update-memory-allocation-fail-age { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Time since last memory allocation failure event | | "Time since last memory allocation failure event |
| (in seconds)"; | | (in seconds)"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPDGEN-AF-SUMMARY-BAG { | | grouping BGP-UPDGEN-AF-SUMMARY-BAG { |
| description | | description |
| "BGP Update generation address-family summary | | "BGP Update generation address-family summary |
| information"; | | information"; |
| leaf update-group-af-name { | | leaf update-group-af-name { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "Address family identifier"; | | "Address family identifier"; |
| } | | } |
| leaf current-update-limit-af { | | leaf current-update-limit-af { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP address-family current AF update limit"; | n | "Current AF update limit"; |
| } | | } |
| leaf update-out-queue-messages { | | leaf update-out-queue-messages { |
| type uint32; | | type uint32; |
| description | | description |
| "OutQueue messages"; | | "OutQueue messages"; |
| } | | } |
| leaf update-out-queue-size { | | leaf update-out-queue-size { |
| type uint32; | | type uint32; |
| description | | description |
| "OutQueue size"; | | "OutQueue size"; |
| } | | } |
| leaf update-throttled { | | leaf update-throttled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "BGP sub-group updates throttled because write | n | "Is update throttled"; |
| limit reached"; | | |
| } | | } |
| leaf update-update-group-count { | | leaf update-update-group-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Update-group count"; | | "Update-group count"; |
| } | | } |
| leaf update-sub-group-count { | | leaf update-sub-group-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Sub-group count"; | | "Sub-group count"; |
| } | | } |
| leaf sub-group-throttled-count { | | leaf sub-group-throttled-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Throttled sub-group count"; | | "Throttled sub-group count"; |
| } | | } |
| leaf refresh-sub-group-count { | | leaf refresh-sub-group-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP address-family refresh sub-group count"; | n | "Refresh sub-group count"; |
| } | | } |
| leaf refresh-sub-group-throttled-count { | | leaf refresh-sub-group-throttled-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Throttled refresh sub-group count"; | | "Throttled refresh sub-group count"; |
| } | | } |
| leaf filter-group-count { | | leaf filter-group-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP address-family filter-group count"; | n | "Filter-group count"; |
| } | | } |
| leaf neighbor-count { | | leaf neighbor-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP sub-group neighbor count"; | n | "Neighbor count"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-UPDGEN-PROC-BAG { | | grouping BGP-UPDGEN-PROC-BAG { |
| description | | description |
| "BGP Update generation Process information"; | | "BGP Update generation Process information"; |
| container update-statistics { | | container update-statistics { |
| description | | description |
| n | "BGP process update statistics"; | n | "Update statistics"; |
| uses BGP-UPDGEN-STATS-BAG; | | uses BGP-UPDGEN-STATS-BAG; |
| } | | } |
| leaf update-out-logging { | | leaf update-out-logging { |
| type boolean; | | type boolean; |
| description | | description |
| "Enable syslog messages for update generation | | "Enable syslog messages for update generation |
| events"; | | events"; |
| } | | } |
| leaf current-update-limit-process { | | leaf current-update-limit-process { |
| type uint32; | | type uint32; |
| description | | description |
| "Current Process update limit"; | | "Current Process update limit"; |
| } | | } |
| leaf configured-update-limit-process { | | leaf configured-update-limit-process { |
| type uint32; | | type uint32; |
| description | | description |
| "Configured Process update limit"; | | "Configured Process update limit"; |
| } | | } |
| leaf update-out-queue-messages { | | leaf update-out-queue-messages { |
| type uint32; | | type uint32; |
| description | | description |
| "OutQueue messages"; | | "OutQueue messages"; |
| } | | } |
| leaf update-out-queue-size { | | leaf update-out-queue-size { |
| type uint32; | | type uint32; |
| description | | description |
| "OutQueue size"; | | "OutQueue size"; |
| } | | } |
| leaf update-throttled { | | leaf update-throttled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag for BGP address-family summary updates | n | |
| throttled"; | | "Is update throttled"; |
| } | | } |
| list update-address-family { | | list update-address-family { |
| description | | description |
| "List of address-families"; | | "List of address-families"; |
| uses BGP-UPDGEN-AF-SUMMARY-BAG; | | uses BGP-UPDGEN-AF-SUMMARY-BAG; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-CONFIG-RELATIVES-BAG { | | grouping BGP-CONFIG-RELATIVES-BAG { |
| description | | description |
| "BGP config ancestors/children information"; | | "BGP config ancestors/children information"; |
| container neighbor-address-xr { | | container neighbor-address-xr { |
| description | | description |
| "Neighbor Address"; | | "Neighbor Address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container af-independent-relatives { | | container af-independent-relatives { |
| description | | description |
| n | "The relatives of theindependent address-family"; | n | "AF-independent relatives"; |
| uses BGP-CONFIG-ENTID; | | uses BGP-CONFIG-ENTID; |
| } | | } |
| leaf group-name { | | leaf group-name { |
| type string; | | type string; |
| description | | description |
| "Entity/group name"; | | "Entity/group name"; |
| } | | } |
| leaf configuration-type { | | leaf configuration-type { |
| type Bgp-entities; | | type Bgp-entities; |
| description | | description |
| "Entity type"; | | "Entity type"; |
| } | | } |
| leaf address-family-identifier { | | leaf address-family-identifier { |
| n | type string; | n | type uint8; |
| description | | description |
| "AF identifier"; | | "AF identifier"; |
| } | | } |
| list af-dependent-relative { | | list af-dependent-relative { |
| max-elements "25"; | | max-elements "25"; |
| description | | description |
| n | "The relatives of thedependent address-family"; | n | "AF-dependent relatives"; |
| uses BGP-CONFIG-ENTID; | | uses BGP-CONFIG-ENTID; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-AF-DEP { | | grouping BGP-AF-DEP { |
| description | | description |
| "BGP AF-dependent configuration information"; | | "BGP AF-dependent configuration information"; |
| n | | n | container orr-root-address { |
| | | description |
| | | "ORR Root Address"; |
| | | uses BGP-ADDRTYPE; |
| | | } |
| container orf-capability-info { | | container orf-capability-info { |
| description | | description |
| "ORF capability item info"; | | "ORF capability item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container default-originate-info { | | container default-originate-info { |
| description | | description |
| n | "The configuration of the defaultinformation | n | "Default-originate item info"; |
| originate"; | | |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container max-prefixes-info { | | container max-prefixes-info { |
| description | | description |
| "Maximum prefixes to accept item info"; | | "Maximum prefixes to accept item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| n | container orr-group-info { | n | container orr-info { |
| description | | description |
| n | "ORR group info"; | n | "Orr item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container next-hop-self-info { | | container next-hop-self-info { |
| description | | description |
| n | "Nexthop attribute for receivedupdates to its own | n | "Next hop self item info"; |
| IP address"; | | |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container next-hop-unchanged-info { | | container next-hop-unchanged-info { |
| description | | description |
| n | "An attribute is unchanged for nexthop"; | n | "Next hop unchanged info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container route-policy-in-info { | | container route-policy-in-info { |
| description | | description |
| "Inbound route policy item info"; | | "Inbound route policy item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container route-policy-out-info { | | container route-policy-out-info { |
| description | | description |
| "Outbound route policy item info"; | | "Outbound route policy item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container prefix-filter-info { | | container prefix-filter-info { |
| description | | description |
| "Inbound prefix based filter item info"; | | "Inbound prefix based filter item info"; |
| n | uses BGP-CONFIG-INFO; | n | |
| } | | |
| container route-policy-retention-info { | | |
| description | | |
| "Inbound Retention policy item info"; | | |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container remove-private-as-info { | | container remove-private-as-info { |
| description | | description |
| "Outbound private-AS removal item info"; | | "Outbound private-AS removal item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container remove-private-as-in-info { | | container remove-private-as-in-info { |
| description | | description |
| "Inbound private-AS removal item info"; | | "Inbound private-AS removal item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container route-reflector-info { | | container route-reflector-info { |
| description | | description |
| "Route-reflector client item info"; | | "Route-reflector client item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container legacy-pe-rt-info { | | container legacy-pe-rt-info { |
| description | | description |
| "Accept-legacy-pe-RT item info"; | | "Accept-legacy-pe-RT item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container af-enabled-info { | | container af-enabled-info { |
| description | | description |
| "Address family activate item info"; | | "Address family activate item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container send-community-info { | | container send-community-info { |
| description | | description |
| "Send community attribute item info"; | | "Send community attribute item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container send-graceful-shutdown-community-info { | | container send-graceful-shutdown-community-info { |
| description | | description |
| "Send Graceful shutdown related community | | "Send Graceful shutdown related community |
| attribute item info"; | | attribute item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container send-extended-community-info { | | container send-extended-community-info { |
| description | | description |
| n | "Sending information aboutBGP extended community"; | n | "Send extended community item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container soft-reconfig-info { | | container soft-reconfig-info { |
| description | | description |
| n | "Information about the BGPsoft-reconfig"; | n | "Soft reconf item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container so-o-info { | | container so-o-info { |
| description | | description |
| "BGP Site-of-Origin info"; | | "BGP Site-of-Origin info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container upd-orig-loopchk-disable-info { | | container upd-orig-loopchk-disable-info { |
| description | | description |
| "Disable originator loopchk info"; | | "Disable originator loopchk info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container weight-info { | | container weight-info { |
| description | | description |
| "Default weight item info"; | | "Default weight item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container allowas-in-info { | | container allowas-in-info { |
| description | | description |
| n | "Allowconfedas-in item info"; | n | "Allowas-in item info"; |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container allow-confedas-in-info { | | |
| description | | |
| "Allowconfedas-in item info"; | | |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container af-long-lived-graceful-start-stale-time-info { | | container af-long-lived-graceful-start-stale-time-info { |
| description | | description |
| "Long-lived-time item info"; | | "Long-lived-time item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container af-long-lived-graceful-start-capable-info { | | container af-long-lived-graceful-start-capable-info { |
| description | | description |
| "Long-lived-time item info"; | | "Long-lived-time item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container as-override-info { | | container as-override-info { |
| description | | description |
| n | "Overriding the autonomous number"; | n | "As-override info "; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container aigp-info { | | container aigp-info { |
| description | | description |
| "AIGP info "; | | "AIGP info "; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container aigp-cost-community-info { | | container aigp-cost-community-info { |
| description | | description |
| "AIGP Cost Community info "; | | "AIGP Cost Community info "; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container aigp-med { | | container aigp-med { |
| description | | description |
| "AIGP MED info "; | | "AIGP MED info "; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container accept-own-info { | | container accept-own-info { |
| description | | description |
| n | "Information of an attributeaccept own"; | n | "Accept-Own info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container multipath-info { | | container multipath-info { |
| description | | description |
| n | "Information about BGP multipath"; | n | "Multipath info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container fspec-valid-info { | | container fspec-valid-info { |
| description | | description |
| "FSPEC Valid info"; | | "FSPEC Valid info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container next-hop-unchanged-mpath-info { | | container next-hop-unchanged-mpath-info { |
| description | | description |
| n | "Next hop attribute is unchangedin multipath"; | n | "Next hop unchanged mpath info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container permanent-network-info { | | container permanent-network-info { |
| description | | description |
| n | "BGP network is permanent"; | n | "Permanent network Info "; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container send-mcast-attr-info { | | container send-mcast-attr-info { |
| description | | description |
| n | "Sending the BGP multicast attributeinformation"; | n | "Send mcast attr info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container advertise-v4-afi-info { | | container advertise-v4-afi-info { |
| description | | description |
| "Advertise Afi Info "; | | "Advertise Afi Info "; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container advertise-v6-afi-info { | | container advertise-v6-afi-info { |
| description | | description |
| "Advertise Afi Info "; | | "Advertise Afi Info "; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container advertise-l2vpn-evpn-afi-info { | | container advertise-l2vpn-evpn-afi-info { |
| description | | description |
| "Advertise Afi Info "; | | "Advertise Afi Info "; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container advertise-dis-info { | | container advertise-dis-info { |
| description | | description |
| "Advertise Afi Info "; | | "Advertise Afi Info "; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container advertise-def-vrf-imp-disable-afi-v4-info { | | container advertise-def-vrf-imp-disable-afi-v4-info { |
| description | | description |
| "Advertise Afi Info "; | | "Advertise Afi Info "; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container advertise-def-vrf-imp-disable-afi-v6-info { | | container advertise-def-vrf-imp-disable-afi-v6-info { |
| description | | description |
| "Advertise Afi Info "; | | "Advertise Afi Info "; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container advertise-vrf-re-imp-disable-afi-v4-info { | | container advertise-vrf-re-imp-disable-afi-v4-info { |
| description | | description |
| "Advertise Afi Info "; | | "Advertise Afi Info "; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container advertise-vrf-re-imp-disable-afi-v6-info { | | container advertise-vrf-re-imp-disable-afi-v6-info { |
| description | | description |
| "Advertise Afi Info "; | | "Advertise Afi Info "; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container advertise-vrf-evpn-re-imp-disable-afi-v4-info { | | container advertise-vrf-evpn-re-imp-disable-afi-v4-info { |
| description | | description |
| "Advertise Afi Info "; | | "Advertise Afi Info "; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container advertise-vrf-evpn-re-imp-disable-afi-v6-info { | | container advertise-vrf-evpn-re-imp-disable-afi-v6-info { |
| description | | description |
| "Advertise Afi Info "; | | "Advertise Afi Info "; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container af-encapsulation-type-info { | | container af-encapsulation-type-info { |
| description | | description |
| n | "The type of the encapsulation"; | n | "Encapsulation type Info "; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container import-afi-info { | | container import-afi-info { |
| description | | description |
| "Import Afi Info "; | | "Import Afi Info "; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container advertise-local-labeled-route-info { | | container advertise-local-labeled-route-info { |
| description | | description |
| "Advertise routes with local-label"; | | "Advertise routes with local-label"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container enforce-multiple-labels-info { | | container enforce-multiple-labels-info { |
| description | | description |
| n | "BGP multiple lables enforcementinformation"; | n | "Enforce multiple labels"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| n | container cluster-id-allow-equal-info { | n | |
| description | | |
| "Cluster ID check disabled info. This is the | | |
| check that allows BGP to accept routes that | | |
| contain a cluster list in which the first | | |
| cluster ID is not equal to therouter's own | | |
| cluster ID."; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container srv6-version4-info { | | |
| description | | |
| "Enable srv6 version 4"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container slow-peer-info { | | |
| description | | |
| "Slow peer related information"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container entropy-label-advertise-disable-info { | | |
| description | | |
| "Disable Entropy Label propagation"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container replace-private-as-info { | | |
| description | | |
| "Outbound private-AS replace item info"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container addpath-receive-capability-info { | | |
| description | | |
| "BGP configuration additional pathcapability of | | |
| receiving"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container addpath-send-capability-info { | | |
| description | | |
| "BGP configuration additional pathcapability of | | |
| sending"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container evpn-gateway-ip-advertisement-disable-info { | | |
| description | | |
| "BGP configuration for EVPN AF advertise | | |
| gateway-ip disable"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| leaf has-orf-capability { | | leaf has-orf-capability { |
| type uint32; | | type uint32; |
| description | | description |
| "ORF capability"; | | "ORF capability"; |
| } | | } |
| leaf is-default-originate-not-disabled { | | leaf is-default-originate-not-disabled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate defaultoriginate is not | n | "TRUE if default-originate is not disabled"; |
| disabled"; | | |
| } | | |
| leaf address-family-identifier { | | |
| type string; | | |
| description | | |
| "Address Family Name"; | | |
| } | | } |
| leaf default-originate-route-policy { | | leaf default-originate-route-policy { |
| type string; | | type string; |
| description | | description |
| n | "The name of the default-originateroute policy"; | n | "Default-originate route policy name"; |
| } | | } |
| leaf max-prefixes { | | leaf max-prefixes { |
| type uint32; | | type uint32; |
| description | | description |
| "Maximum prefixes to accept"; | | "Maximum prefixes to accept"; |
| } | | } |
| leaf max-prefix-warn-threshold { | | leaf max-prefix-warn-threshold { |
| type uint32; | | type uint32; |
| description | | description |
| "Warning message threshhold"; | | "Warning message threshhold"; |
| } | | } |
| leaf is-max-prefix-warn-only { | | leaf is-max-prefix-warn-only { |
| type boolean; | | type boolean; |
| description | | description |
| "Warning messages only"; | | "Warning messages only"; |
| } | | } |
| leaf max-prefix-restart-time { | | leaf max-prefix-restart-time { |
| type uint32; | | type uint32; |
| description | | description |
| "Restart time Value"; | | "Restart time Value"; |
| } | | } |
| n | leaf orrg-roup-name { | n | |
| type string; | | |
| description | | |
| "Name of Optimal Route reflectiongroup the | | |
| neighbor is part of"; | | |
| } | | |
| leaf is-max-prefix-discard-extra-paths { | | leaf is-max-prefix-discard-extra-paths { |
| type boolean; | | type boolean; |
| description | | description |
| "Discard extra paths"; | | "Discard extra paths"; |
| } | | } |
| leaf is-next-hop-self-disabled { | | leaf is-next-hop-self-disabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Disable next-hop calc"; | | "Disable next-hop calc"; |
| } | | } |
| leaf is-next-hop-unchanged { | | leaf is-next-hop-unchanged { |
| type boolean; | | type boolean; |
| description | | description |
| "Don't change next-hop"; | | "Don't change next-hop"; |
| } | | } |
| leaf permanent-network { | | leaf permanent-network { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate BGP networkis permanent"; | n | "Permanent Network"; |
| } | | } |
| leaf route-policy-in { | | leaf route-policy-in { |
| type string; | | type string; |
| description | | description |
| "Inbound route policy name"; | | "Inbound route policy name"; |
| } | | } |
| leaf route-policy-out { | | leaf route-policy-out { |
| type string; | | type string; |
| description | | description |
| "Outbound route policy name"; | | "Outbound route policy name"; |
| } | | } |
| leaf prefix-orf-filter { | | leaf prefix-orf-filter { |
| type string; | | type string; |
| description | | description |
| "Inbound prefix based filter"; | | "Inbound prefix based filter"; |
| } | | } |
| n | leaf route-policy-ret { | n | |
| type string; | | |
| description | | |
| "Inbound route retention route-policy name"; | | |
| } | | |
| leaf remove-private-as-out { | | leaf remove-private-as-out { |
| type boolean; | | type boolean; |
| description | | description |
| "Outbound private-AS removal"; | | "Outbound private-AS removal"; |
| } | | } |
| leaf entire-aspath-out { | | leaf entire-aspath-out { |
| type boolean; | | type boolean; |
| description | | description |
| "Outbound private-AS removalif the entire AS Path | | "Outbound private-AS removalif the entire AS Path |
| hasprivate ASes"; | | hasprivate ASes"; |
| } | | } |
| n | leaf remove-private-as-int { | n | |
| type boolean; | | |
| description | | |
| "Remove private-AS internalif the internal AS | | |
| Path hasprivate ASes"; | | |
| } | | |
| leaf remove-private-asin { | | leaf remove-private-asin { |
| type boolean; | | type boolean; |
| description | | description |
| "Inbound private-AS removal"; | | "Inbound private-AS removal"; |
| } | | } |
| leaf entire-aspath-in { | | leaf entire-aspath-in { |
| type boolean; | | type boolean; |
| description | | description |
| "Inbound private-AS removal if the entire AS Path | | "Inbound private-AS removal if the entire AS Path |
| has private ASes"; | | has private ASes"; |
| } | | } |
| leaf client-route-reflector { | | leaf client-route-reflector { |
| type boolean; | | type boolean; |
| description | | description |
| "Route-reflector client"; | | "Route-reflector client"; |
| } | | } |
| leaf accept-route-legacy-pe-rt { | | leaf accept-route-legacy-pe-rt { |
| type boolean; | | type boolean; |
| description | | description |
| "accept-legacy-pe RT route"; | | "accept-legacy-pe RT route"; |
| } | | } |
| leaf is-af-enabled { | | leaf is-af-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Entity is activated for this address family"; | | "Entity is activated for this address family"; |
| } | | } |
| leaf send-community-attribute { | | leaf send-community-attribute { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate communityattribute is sent"; | n | "Send community attribute"; |
| } | | } |
| leaf send-graceful-shut-community-attributes { | | leaf send-graceful-shut-community-attributes { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate graceful shutdown related | n | "Send Graceful shutdown related community |
| community attributes are sent"; | | attributes"; |
| } | | } |
| leaf send-extended-community-attribute { | | leaf send-extended-community-attribute { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate BGP extended community | n | "Send extended community attribute"; |
| attribute is sent"; | | |
| } | | } |
| leaf soft-reconfig-not-disabled { | | leaf soft-reconfig-not-disabled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if BGP soft reconfiguration is | n | "TRUE if soft reconf is not disabled"; |
| not disabled"; | | |
| } | | } |
| leaf alway-use-soft-reconfig { | | leaf alway-use-soft-reconfig { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if soft reconfig is always used"; | n | "Always use soft reconfig"; |
| } | | } |
| leaf upd-orig-loopchk-disable { | | leaf upd-orig-loopchk-disable { |
| type boolean; | | type boolean; |
| description | | description |
| "Disable originator loop check"; | | "Disable originator loop check"; |
| } | | } |
| leaf site-of-origin { | | leaf site-of-origin { |
| type string; | | type string; |
| description | | description |
| n | "The routes that are originatedfrom site"; | n | "Site of Origin"; |
| } | | } |
| leaf default-weight { | | leaf default-weight { |
| type uint32; | | type uint32; |
| description | | description |
| n | "The default value of the BGP weight"; | n | "Default weight"; |
| } | | } |
| leaf default-allowas { | | leaf default-allowas { |
| type uint32; | | type uint32; |
| description | | description |
| "Default allowas_in count"; | | "Default allowas_in count"; |
| n | } | n | |
| leaf default-confed-allowas { | | |
| type uint32; | | |
| description | | |
| "Default allowconfedas_in count"; | | |
| } | | |
| leaf af-retention-stale-time { | | |
| type uint32; | | |
| description | | |
| "Stale time in route retention"; | | |
| } | | |
| leaf af-ret-policy { | | |
| type string; | | |
| description | | |
| "Retention route policy name"; | | |
| } | | } |
| leaf af-long-lived-graceful-restart-stale-time-send { | | leaf af-long-lived-graceful-restart-stale-time-send { |
| type uint32; | | type uint32; |
| description | | description |
| "Stale time to be sent in long-lived | | "Stale time to be sent in long-lived |
| graceful-restart capability"; | | graceful-restart capability"; |
| } | | } |
| leaf af-long-lived-graceful-restart-stale-time-accept { | | leaf af-long-lived-graceful-restart-stale-time-accept { |
| type uint32; | | type uint32; |
| description | | description |
| "Maxmimum acceptable long-lived stale time | | "Maxmimum acceptable long-lived stale time |
| acceptable from neighbor"; | | acceptable from neighbor"; |
| } | | } |
| leaf af-long-lived-graceful-restart-capable { | | leaf af-long-lived-graceful-restart-capable { |
| type uint32; | | type uint32; |
| description | | description |
| n | "The time of the long-lived BGPgraceful-restart"; | n | "Long-lived graceful-restart capable"; |
| } | | } |
| leaf is-as-override-disabled { | | leaf is-as-override-disabled { |
| type boolean; | | type boolean; |
| description | | description |
| "Disable as override"; | | "Disable as override"; |
| } | | } |
| leaf is-aigp-enabled { | | leaf is-aigp-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "AIGP enabled"; | | "AIGP enabled"; |
| } | | } |
| leaf is-aigp-cost-community-enabled { | | leaf is-aigp-cost-community-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate cost of theAIGP community is | n | "AIGP cost community enabled"; |
| enabled"; | | |
| } | | } |
| leaf is-aigp-cost-community-id { | | leaf is-aigp-cost-community-id { |
| type uint32; | | type uint32; |
| description | | description |
| "AIGP cost community ID"; | | "AIGP cost community ID"; |
| } | | } |
| leaf is-aigp-cost-community-transitive { | | leaf is-aigp-cost-community-transitive { |
| type uint32; | | type uint32; |
| description | | description |
| "AIGP cost community ID is transitive"; | | "AIGP cost community ID is transitive"; |
| } | | } |
| leaf aigp-cost-community-poi { | | leaf aigp-cost-community-poi { |
| type uint32; | | type uint32; |
| description | | description |
| "Point of insertion for AIGP cost community"; | | "Point of insertion for AIGP cost community"; |
| } | | } |
| leaf is-aigp-med-enabled { | | leaf is-aigp-med-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "AIGP to MED enabled"; | | "AIGP to MED enabled"; |
| } | | } |
| leaf accept-own { | | leaf accept-own { |
| type boolean; | | type boolean; |
| description | | description |
| "Accept Own"; | | "Accept Own"; |
| } | | } |
| leaf multipath { | | leaf multipath { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate BGP multipath"; | n | "multipath"; |
| } | | } |
| leaf is-fspec-valid-enabled { | | leaf is-fspec-valid-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| "FSPEC VALID enabled"; | | "FSPEC VALID enabled"; |
| } | | } |
| leaf is-next-hop-unchanged-mpath { | | leaf is-next-hop-unchanged-mpath { |
| type boolean; | | type boolean; |
| description | | description |
| "Don't change mpath next-hop"; | | "Don't change mpath next-hop"; |
| } | | } |
| leaf is-send-mcast-attr-enabled { | | leaf is-send-mcast-attr-enabled { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate multicastattribute enabled is | n | "Send mcast attr enabled"; |
| sent"; | | |
| } | | } |
| leaf advertise-v4 { | | leaf advertise-v4 { |
| type uint8; | | type uint8; |
| description | | description |
| "Advertise afi"; | | "Advertise afi"; |
| } | | } |
| leaf advertise-v6 { | | leaf advertise-v6 { |
| type uint8; | | type uint8; |
| description | | description |
| "Advertise afi"; | | "Advertise afi"; |
| } | | } |
| leaf advertise-l2vpn-evpn { | | leaf advertise-l2vpn-evpn { |
| type uint8; | | type uint8; |
| description | | description |
| "Advertise afi"; | | "Advertise afi"; |
| } | | } |
| leaf advertise-disable { | | leaf advertise-disable { |
| type uint8; | | type uint8; |
| description | | description |
| "Advertise afi"; | | "Advertise afi"; |
| } | | } |
| leaf advertise-def-vrf-imp-disable-v4 { | | leaf advertise-def-vrf-imp-disable-v4 { |
| type uint8; | | type uint8; |
| description | | description |
| "Advertise afi"; | | "Advertise afi"; |
| } | | } |
| leaf advertise-def-vrf-imp-disable-v6 { | | leaf advertise-def-vrf-imp-disable-v6 { |
| type uint8; | | type uint8; |
| description | | description |
| "Advertise afi"; | | "Advertise afi"; |
| } | | } |
| leaf advertise-vrf-re-imp-disable-v4 { | | leaf advertise-vrf-re-imp-disable-v4 { |
| type uint8; | | type uint8; |
| description | | description |
| "Advertise afi"; | | "Advertise afi"; |
| } | | } |
| leaf advertise-vrf-re-imp-disable-v6 { | | leaf advertise-vrf-re-imp-disable-v6 { |
| type uint8; | | type uint8; |
| description | | description |
| "Advertise afi"; | | "Advertise afi"; |
| } | | } |
| leaf advertise-vrf-evpn-re-imp-disable-v4 { | | leaf advertise-vrf-evpn-re-imp-disable-v4 { |
| type uint8; | | type uint8; |
| description | | description |
| "Advertise afi"; | | "Advertise afi"; |
| } | | } |
| leaf advertise-vrf-evpn-re-imp-disable-v6 { | | leaf advertise-vrf-evpn-re-imp-disable-v6 { |
| type uint8; | | type uint8; |
| description | | description |
| "Advertise afi"; | | "Advertise afi"; |
| } | | } |
| leaf encapsulation-type { | | leaf encapsulation-type { |
| type uint32; | | type uint32; |
| description | | description |
| n | "The type of the BGP encapsulation"; | n | "Encapsulation type"; |
| } | | } |
| leaf import { | | leaf import { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate BGP importing"; | n | "Import"; |
| } | | } |
| leaf import-stitching { | | leaf import-stitching { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate if BGP stitching RTs are | n | "Import stitching RTs"; |
| imported"; | | |
| } | | } |
| leaf import-reoriginate { | | leaf import-reoriginate { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate reoriginate import"; | n | "Import reoriginate"; |
| } | | } |
| leaf import-reoriginate-stitching { | | leaf import-reoriginate-stitching { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate reoriginate stitchingis | n | "Import reoriginate stitching RTs"; |
| imported in RTs"; | | |
| } | | } |
| leaf advertise-local-labeled-route { | | leaf advertise-local-labeled-route { |
| type uint32; | | type uint32; |
| description | | description |
| "Advertise routes with local-label"; | | "Advertise routes with local-label"; |
| } | | } |
| leaf enforce-multiple-labels { | | leaf enforce-multiple-labels { |
| type uint32; | | type uint32; |
| description | | description |
| n | "BGP multiple labels enforced"; | n | "Enforce multiple labels"; |
| } | | |
| leaf srv6-version4 { | | |
| type boolean; | | |
| description | | |
| "SRV6 Version4 compatible neighbor"; | | |
| } | | |
| leaf cluster-id-check-disabled { | | |
| type boolean; | | |
| description | | |
| "Flag to indicate cluster ID check is disabled. | | |
| This allows BGP to accept routes that may | | |
| contain a cluster list in which the first | | |
| cluster ID is not equal to the router's own | | |
| cluster ID."; | | |
| } | | |
| leaf slow-peer-static-flag { | | |
| type boolean; | | |
| description | | |
| "Slow peer static enabled"; | | |
| } | | |
| leaf slow-peer-dynamic-flag { | | |
| type boolean; | | |
| description | | |
| "Slow peer dynamic enabled"; | | |
| } | | |
| leaf slow-peer-dynamic-threshold { | | |
| type uint16; | | |
| description | | |
| "Threshold for dynamic slow peer detection"; | | |
| } | | |
| leaf slow-peer-dynamic-disable { | | |
| type boolean; | | |
| description | | |
| "Slow peer dynamic disable"; | | |
| } | | |
| leaf rpki-options { | | |
| type uint32; | | |
| description | | |
| "Options to indicate if rpki tested paths are to | | |
| be stored"; | | |
| } | | |
| leaf entropy-label-advertise-disable { | | |
| type boolean; | | |
| description | | |
| "Disable Entropy Label propagation"; | | |
| } | | |
| leaf replace-private-as-out { | | |
| type boolean; | | |
| description | | |
| "Outbound private-AS replace"; | | |
| } | | |
| leaf addpath-receive-capability { | | |
| type uint32; | | |
| description | | |
| "Indicates if addpath receive capability is | | |
| enabled or disabled"; | | |
| } | | |
| leaf addpath-send-capability { | | |
| type uint32; | | |
| description | | |
| "Indicates if addpath send capability is enabled | | |
| or disabled"; | | |
| } | | |
| leaf evpn-gateway-ip-advertisement-disable { | | |
| type boolean; | | |
| description | | |
| "EVPN Gateway IP Advertisement Disable"; | | |
| } | | } |
| } | | } |
| | | |
| grouping BGP-CONFIG-ENTID { | | grouping BGP-CONFIG-ENTID { |
| description | | description |
| "BGP config group entity identification"; | | "BGP config group entity identification"; |
| list bgp-config-entid { | | list bgp-config-entid { |
| description | | description |
| n | "Next entry in the list"; | n | "bgp config entid"; |
| container neighbor-address { | | container neighbor-address { |
| description | | description |
| n | "Ip address of the neighor"; | n | "Neighbor Address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| leaf address-family-identifier { | | leaf address-family-identifier { |
| n | type string; | n | type uint8; |
| description | | description |
| n | "Identifier of the BGPconfig group entity"; | n | "Address family identfier"; |
| } | | } |
| leaf configuration-type { | | leaf configuration-type { |
| type Bgp-entities; | | type Bgp-entities; |
| description | | description |
| "Entity type"; | | "Entity type"; |
| } | | } |
| leaf group-name { | | leaf group-name { |
| type string; | | type string; |
| description | | description |
| n | "Name of the BGP configgroup entity"; | n | "Group name"; |
| } | | } |
| } | | } |
| } | | } |
| | | |
| grouping BGP-CONFIG-INFO { | | grouping BGP-CONFIG-INFO { |
| description | | description |
| "BGP item config information"; | | "BGP item config information"; |
| container inheritance-chain { | | container inheritance-chain { |
| description | | description |
| "Pointer to the inheritance chain"; | | "Pointer to the inheritance chain"; |
| uses BGP-CONFIG-ENTID; | | uses BGP-CONFIG-ENTID; |
| } | | } |
| leaf is-item-configured { | | leaf is-item-configured { |
| type boolean; | | type boolean; |
| description | | description |
| "TRUE if the item value is a configured value | | "TRUE if the item value is a configured value |
| different from the default"; | | different from the default"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-AF-INDEP { | | grouping BGP-AF-INDEP { |
| description | | description |
| "BGP AF-independent configuration information"; | | "BGP AF-independent configuration information"; |
| container local-ip-address { | | container local-ip-address { |
| description | | description |
| "Local ipv4 or ipv6 address for neighbor | | "Local ipv4 or ipv6 address for neighbor |
| connection"; | | connection"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container local-address-subnet { | | container local-address-subnet { |
| description | | description |
| "local address ipv4 or ipv6 address mask"; | | "local address ipv4 or ipv6 address mask"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container remote-as-info { | | container remote-as-info { |
| description | | description |
| "Remote AS number item info"; | | "Remote AS number item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container speaker-id-info { | | container speaker-id-info { |
| description | | description |
| "Configured speaker ID item info"; | | "Configured speaker ID item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container min-advertisement-info { | | container min-advertisement-info { |
| description | | description |
| "Minimum advertisement interval item info"; | | "Minimum advertisement interval item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container description-info { | | container description-info { |
| description | | description |
| n | "Description informationof BGP configuration"; | n | "Description item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container ebgp-hop-count-info { | | container ebgp-hop-count-info { |
| description | | description |
| "EBGP neighbors hop count item info"; | | "EBGP neighbors hop count item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container tcpmss-info { | | container tcpmss-info { |
| description | | description |
| "TCP Maximum Segment Size item info"; | | "TCP Maximum Segment Size item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| n | container tcpmtu-info { | n | |
| description | | |
| "TCP Path MTU Discovery item info"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container bmp-servers-info { | | container bmp-servers-info { |
| description | | description |
| "BMP Servers Configuredinfo"; | | "BMP Servers Configuredinfo"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container keychain-info { | | container keychain-info { |
| description | | description |
| "Neighbor Keychain item info"; | | "Neighbor Keychain item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container local-as-info { | | container local-as-info { |
| description | | description |
| "Local AS number item info"; | | "Local AS number item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container password-info { | | container password-info { |
| description | | description |
| "Neighbor password item info"; | | "Neighbor password item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container receive-buffer-info { | | container receive-buffer-info { |
| description | | description |
| "Receive buffer sizes item info"; | | "Receive buffer sizes item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container send-buffer-info { | | container send-buffer-info { |
| description | | description |
| "Send buffer sizes item info"; | | "Send buffer sizes item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container shutdown-info { | | container shutdown-info { |
| description | | description |
| "Shutdown item info"; | | "Shutdown item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container timers-info { | | container timers-info { |
| description | | description |
| "Timers item info"; | | "Timers item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container local-address-info { | | container local-address-info { |
| description | | description |
| n | "Local address for theBGP configuration"; | n | "Local address item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container msg-log-in-info { | | container msg-log-in-info { |
| description | | description |
| "Message Log Inbound item info"; | | "Message Log Inbound item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container msg-log-out-info { | | container msg-log-out-info { |
| description | | description |
| "Message Log Outbound item info"; | | "Message Log Outbound item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container update-source-info { | | container update-source-info { |
| description | | description |
| n | "Updating the source information"; | n | "Update source item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container local-address-subnet-info { | | container local-address-subnet-info { |
| description | | description |
| n | "Local address of the subnet"; | n | "Local address subnet item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container dmz-link-bandwidth-info { | | container dmz-link-bandwidth-info { |
| description | | description |
| "DMZ link bandwidth item "; | | "DMZ link bandwidth item "; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container ebgp-recv-dmz-info { | | container ebgp-recv-dmz-info { |
| description | | description |
| "EBGP receive DMZ link bandwidth item info"; | | "EBGP receive DMZ link bandwidth item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container ebgp-send-dmz-info { | | container ebgp-send-dmz-info { |
| description | | description |
| "EBGP send DMZ link bandwidth item info"; | | "EBGP send DMZ link bandwidth item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container ttl-security-info { | | container ttl-security-info { |
| description | | description |
| "BGP TTL Security item info"; | | "BGP TTL Security item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| n | | n | container suppress4-bbyte-as-info { |
| | | description |
| | | "BGP suppress 4byte-as item info"; |
| | | uses BGP-CONFIG-INFO; |
| | | } |
| container session-open-mode-info { | | container session-open-mode-info { |
| description | | description |
| "TCP conn open mode info"; | | "TCP conn open mode info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container bfd-info { | | container bfd-info { |
| description | | description |
| "BFD item info"; | | "BFD item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container bfd-mininterval-info { | | container bfd-mininterval-info { |
| description | | description |
| "BFD Mininterval item info"; | | "BFD Mininterval item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container bfd-multiplier-info { | | container bfd-multiplier-info { |
| description | | description |
| "BFD Multiplier item info"; | | "BFD Multiplier item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container tos-info { | | container tos-info { |
| description | | description |
| "TOS item info"; | | "TOS item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container nsr-disabled-info { | | container nsr-disabled-info { |
| description | | description |
| "NSR item info"; | | "NSR item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container graceful-restart-disabled-info { | | container graceful-restart-disabled-info { |
| description | | description |
| n | "Information of disabled gracefulrestart"; | n | "Graceful-restart item info"; |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container graceful-restart-helper-info { | | |
| description | | |
| "Information of helper mode gracefulrestart"; | | |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container nbr-restart-time-info { | | container nbr-restart-time-info { |
| description | | description |
| "Restart time item info"; | | "Restart time item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container nbr-stale-path-time-info { | | container nbr-stale-path-time-info { |
| description | | description |
| "Stale-path time item info"; | | "Stale-path time item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container nbr-enforce-first-as-info { | | container nbr-enforce-first-as-info { |
| description | | description |
| "Neighbor enforce first AS info"; | | "Neighbor enforce first AS info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container cluster-id-info { | | container cluster-id-info { |
| description | | description |
| "Cluster ID item info"; | | "Cluster ID item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container ignore-connected-info { | | container ignore-connected-info { |
| description | | description |
| n | "Connection information is ignored"; | n | "Ignore Connected Info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container internal-vpn-client-info { | | container internal-vpn-client-info { |
| description | | description |
| "Internal VPN Client Info"; | | "Internal VPN Client Info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container addpath-send-capability-info { | | container addpath-send-capability-info { |
| description | | description |
| n | "BGP configuration additional pathcapability of | n | "Addpath send capability info"; |
| sending"; | | |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container addpath-receive-capability-info { | | container addpath-receive-capability-info { |
| description | | description |
| n | "BGP configuration additional pathcapability of | n | "Addpath receive capability info"; |
| receiving"; | | |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container egress-peer-engineering-info { | | container egress-peer-engineering-info { |
| description | | description |
| n | "Information for the peers egresstraffic"; | n | "Egress Peer Engineering info"; |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container epe-peer-set-segment-id-info { | | |
| description | | |
| "Information for the EPE Peer set"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container epe-peer-segment-id-info { | | |
| description | | |
| "Information for the EPE Peer SID"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container update-in-error-handling-info { | | |
| description | | |
| "Error-handling update in error handling info"; | | |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container update-error-handling-no-reset-info { | | container update-error-handling-no-reset-info { |
| description | | description |
| "Error-handling avoid-reset config info"; | | "Error-handling avoid-reset config info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| n | container update-error-handling-treat-as-withdraw-info { | n | |
| description | | |
| "Error-handling treat-as-withdraw config info"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container prefix-validation-disable-info { | | container prefix-validation-disable-info { |
| description | | description |
| "RPKI disable info"; | | "RPKI disable info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container prefix-validation-use-validit-info { | | container prefix-validation-use-validit-info { |
| description | | description |
| "RPKI use validity"; | | "RPKI use validity"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container prefix-validation-allow-invalid-info { | | container prefix-validation-allow-invalid-info { |
| description | | description |
| "RPKI allow invalid info"; | | "RPKI allow invalid info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container prefix-validation-signal-ibgp-info { | | container prefix-validation-signal-ibgp-info { |
| description | | description |
| "RPKI signal ibgp info"; | | "RPKI signal ibgp info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container neighbor-update-filter-exists-info { | | container neighbor-update-filter-exists-info { |
| description | | description |
| "Neighbor update filter configuration info"; | | "Neighbor update filter configuration info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container neighbor-update-filter-message-buffer-count-info { | | container neighbor-update-filter-message-buffer-count-info { |
| description | | description |
| n | "Number of neighbor messages filtered"; | n | "Neighbor update filter message buffer count info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container neighbor-update-filter-syslog-disable-info { | | container neighbor-update-filter-syslog-disable-info { |
| description | | description |
| n | "Update in filtering loggingdisable"; | n | "Neighbor update filter syslog disable info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container neighbor-update-filter-attribute-info { | | container neighbor-update-filter-attribute-info { |
| description | | description |
| n | "Update in filteringattribute filter group"; | n | "Neighbor update filter attribute-filter group |
| | | info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container graceful-shutdown-info { | | container graceful-shutdown-info { |
| description | | description |
| n | "Graceful BGP session shutdown"; | n | "GracefulShutdown info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container graceful-shutdown-loc-pref-info { | | container graceful-shutdown-loc-pref-info { |
| description | | description |
| n | "The local prefrence for graceful shutdown"; | n | "GracefulShutdownLocPref info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container graceful-shutdown-as-prepends-info { | | container graceful-shutdown-as-prepends-info { |
| description | | description |
| "GracefulShutdownASPrepends info"; | | "GracefulShutdownASPrepends info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container graceful-shutdown-activate-info { | | container graceful-shutdown-activate-info { |
| description | | description |
| n | "Information for the activation ofgraceful | n | "GracefulShutdownAcivate info"; |
| shutdown"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container graceful-shutdown-bandwidth-aware-info { | | |
| description | | |
| "Bandwidth-Aware Graceful-Maintenance | | |
| configuration info"; | | |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container update-in-safi14-merge-info { | | container update-in-safi14-merge-info { |
| description | | description |
| "Merge SAFI-1 and SAFI-4 updates from neighbor | | "Merge SAFI-1 and SAFI-4 updates from neighbor |
| info"; | | info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container capability-negotiation-suppressed-info { | | container capability-negotiation-suppressed-info { |
| description | | description |
| n | "Information for the negotiation of suppressed | n | "Capability negotiation suppressed info"; |
| capability"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container suppress4-bbyte-as-info { | | |
| description | | |
| "BGP suppress 4byte-as item info"; | | |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container neighbor-remote-as-list-info { | | container neighbor-remote-as-list-info { |
| description | | description |
| "Neighbor range remote-as-list group info"; | | "Neighbor range remote-as-list group info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container max-peers-info { | | container max-peers-info { |
| description | | description |
| "Max dynamic nbrs in range info"; | | "Max dynamic nbrs in range info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container idle-watch-time-info { | | container idle-watch-time-info { |
| description | | description |
| "Idle Watch time item info"; | | "Idle Watch time item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| container ao-keychain-info { | | container ao-keychain-info { |
| description | | description |
| "Neighbor AO keychain item info"; | | "Neighbor AO keychain item info"; |
| uses BGP-CONFIG-INFO; | | uses BGP-CONFIG-INFO; |
| } | | } |
| n | container extended-nh-encoding-capability-suppressed-info { | n | |
| description | | |
| "Information for the extended nexthop encoding | | |
| capability"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container default-policy-action-inbound-info { | | |
| description | | |
| "Information on default policy action when | | |
| inbound policy is not satidfied"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container default-policy-action-outbound-info { | | |
| description | | |
| "Information on default policy action when | | |
| outbound policy is not satidfied"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container log-up-down-configured-info { | | |
| description | | |
| "Neighbor log state change enabled"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container log-up-down-disable-configured-info { | | |
| description | | |
| "Neighbor log state change disabled"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container maximum-prefix-restart-time-info { | | |
| description | | |
| "Information on Max Prefix Restart timer"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container evpn-link-bandwidth-info { | | |
| description | | |
| "EVPN Link Bandwidth Info "; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container dampening-info { | | |
| description | | |
| "Information on dampening configuration"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container allowas-in-info { | | |
| description | | |
| "Allowas-in item info"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container sent-community-to-neighbor-info { | | |
| description | | |
| "Information on Send Community"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container sent-extended-community-to-neighbor-info { | | |
| description | | |
| "Information on Send ExtendedCommunity"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container as-override-info { | | |
| description | | |
| "Overriding the autonomous number"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container nbr-disable-peer-as-info { | | |
| description | | |
| "NBR Disable Peer AS"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container nbr-fast-fallover-info { | | |
| description | | |
| "Nbr Fast Fallover item info"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| container ipfwd-preferred-info { | | |
| description | | |
| "IP Frowarding Info"; | | |
| uses BGP-CONFIG-INFO; | | |
| } | | |
| leaf remote-as-number-xx { | | leaf remote-as-number-xx { |
| type uint32; | | type uint32; |
| description | | description |
| "First half of Remote ASN"; | | "First half of Remote ASN"; |
| } | | } |
| leaf remote-as-number-yy { | | leaf remote-as-number-yy { |
| type uint32; | | type uint32; |
| description | | description |
| "Second half of Remote ASN"; | | "Second half of Remote ASN"; |
| } | | } |
| leaf configured-speaker-id { | | leaf configured-speaker-id { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Identification for the configuredspeaker"; | n | "Configured speaker ID"; |
| } | | } |
| leaf tcp-mss { | | leaf tcp-mss { |
| type uint32; | | type uint32; |
| description | | description |
| "Maximum Segment Size"; | | "Maximum Segment Size"; |
| } | | } |
| n | leaf tcp-mtu { | n | |
| type uint32; | | |
| description | | |
| "TCP Path MTU Discovery enabled"; | | |
| } | | |
| leaf min-advertisement-interval { | | leaf min-advertisement-interval { |
| type uint32; | | type uint32; |
| n | | n | units "second"; |
| description | | description |
| n | "Minimum amount of time beforesending an | n | "Minimum advertisement interval, secs part"; |
| advertisement"; | | |
| } | | } |
| leaf min-advertisement-interval-msecs { | | leaf min-advertisement-interval-msecs { |
| type uint32; | | type uint32; |
| units "millisecond"; | | units "millisecond"; |
| description | | description |
| n | "Minimum advertisement time between updates for a | n | "Minimum advertisement interval, msecs part"; |
| neighborsession in milliseconds"; | | |
| } | | } |
| leaf description { | | leaf description { |
| type string; | | type string; |
| description | | description |
| n | "BGP address-family independentconfiguration | n | |
| description"; | | "Description"; |
| } | | } |
| leaf ebgp-hop-count { | | leaf ebgp-hop-count { |
| type uint32; | | type uint32; |
| description | | description |
| "EBGP neighbors hop count"; | | "EBGP neighbors hop count"; |
| } | | } |
| leaf bmp-servers { | | leaf bmp-servers { |
| type uint32; | | type uint32; |
| description | | description |
| "BMP Servers activated"; | | "BMP Servers activated"; |
| } | | } |
| leaf is-ebgp-multihop-bgp-mpls-forwarding-disabled { | | leaf is-ebgp-multihop-bgp-mpls-forwarding-disabled { |
| type boolean; | | type boolean; |
| description | | description |
| "If true, MPLS and NULL rewrite is disabled; if | | "If true, MPLS and NULL rewrite is disabled; if |
| false, it is enabled"; | | false, it is enabled"; |
| } | | } |
| leaf keychain { | | leaf keychain { |
| type string; | | type string; |
| description | | description |
| "Neighbor keychain Name"; | | "Neighbor keychain Name"; |
| } | | } |
| leaf local-as-number-xx { | | leaf local-as-number-xx { |
| type uint32; | | type uint32; |
| description | | description |
| "First half of Local ASN"; | | "First half of Local ASN"; |
| } | | } |
| leaf local-as-number-yy { | | leaf local-as-number-yy { |
| type uint32; | | type uint32; |
| description | | description |
| "Second half of Local ASN"; | | "Second half of Local ASN"; |
| } | | } |
| leaf local-as-no-prepend { | | leaf local-as-no-prepend { |
| type boolean; | | type boolean; |
| description | | description |
| "Local AS no-prepend option"; | | "Local AS no-prepend option"; |
| } | | } |
| leaf password { | | leaf password { |
| type string; | | type string; |
| description | | description |
| "Neighbor password"; | | "Neighbor password"; |
| } | | } |
| leaf socket-buffer-receive-size { | | leaf socket-buffer-receive-size { |
| type uint32; | | type uint32; |
| description | | description |
| "Socket receive buffer size"; | | "Socket receive buffer size"; |
| } | | } |
| leaf bgp-buffer-receive-size { | | leaf bgp-buffer-receive-size { |
| type uint32; | | type uint32; |
| description | | description |
| "BGP receive buffer size"; | | "BGP receive buffer size"; |
| } | | } |
| leaf socket-buffer-send-size { | | leaf socket-buffer-send-size { |
| type uint32; | | type uint32; |
| description | | description |
| "Socket send buffer size"; | | "Socket send buffer size"; |
| } | | } |
| leaf bgp-buffer-send-size { | | leaf bgp-buffer-send-size { |
| type uint32; | | type uint32; |
| description | | description |
| "BGP send buffer size"; | | "BGP send buffer size"; |
| } | | } |
| leaf adminstrative-shutdown { | | leaf adminstrative-shutdown { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate peer is administratively | n | "Administrative shutdown"; |
| shutdown"; | | |
| } | | } |
| leaf keepalive-interval { | | leaf keepalive-interval { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Timer for the keepalive event"; | n | "Keepalive interval"; |
| } | | } |
| leaf hold-time-value { | | leaf hold-time-value { |
| type uint32; | | type uint32; |
| description | | description |
| "Holdtime"; | | "Holdtime"; |
| } | | } |
| leaf min-acc-hold-time-value { | | leaf min-acc-hold-time-value { |
| type uint32; | | type uint32; |
| description | | description |
| "Min acceptable holdtimefrom neighbor"; | | "Min acceptable holdtimefrom neighbor"; |
| } | | } |
| leaf msg-log-in-buf-count { | | leaf msg-log-in-buf-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Message Log buffer Inbound count"; | n | "Message Log Inbound buffer count"; |
| } | | } |
| leaf msg-log-out-buf-count { | | leaf msg-log-out-buf-count { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Message Log buffer Outbound count"; | n | "Message Log Outbound buffer count"; |
| } | | } |
| leaf route-updates-source { | | leaf route-updates-source { |
| type string; | | type string; |
| description | | description |
| "Source of routing updates"; | | "Source of routing updates"; |
| } | | } |
| leaf local-address-subnet-len { | | leaf local-address-subnet-len { |
| type uint32; | | type uint32; |
| description | | description |
| "local address prefix len"; | | "local address prefix len"; |
| } | | } |
| leaf dmz-link-bandwidth { | | leaf dmz-link-bandwidth { |
| type uint32; | | type uint32; |
| description | | description |
| "Propagate the DMZ link bandwidth"; | | "Propagate the DMZ link bandwidth"; |
| } | | } |
| leaf ebgp-recv-dmz { | | leaf ebgp-recv-dmz { |
| type uint32; | | type uint32; |
| description | | description |
| "Receive Bandwidth of link to single-hop eBGP | | "Receive Bandwidth of link to single-hop eBGP |
| peer"; | | peer"; |
| } | | } |
| leaf ebgp-send-dmz-mode { | | leaf ebgp-send-dmz-mode { |
| type Bgp-ebgp-send-dmz-enable-mode; | | type Bgp-ebgp-send-dmz-enable-mode; |
| description | | description |
| "Send DMZ link bandwidthto ebgp peer"; | | "Send DMZ link bandwidthto ebgp peer"; |
| } | | } |
| leaf ttl-security { | | leaf ttl-security { |
| type uint32; | | type uint32; |
| description | | description |
| "Enable BGP TTL Security"; | | "Enable BGP TTL Security"; |
| } | | } |
| n | | n | leaf suppress4-byte-as { |
| | | type uint32; |
| | | description |
| | | "Suppress BGP 4byteas Cap"; |
| | | } |
| leaf update-in-safi14-merge { | | leaf update-in-safi14-merge { |
| type uint32; | | type uint32; |
| description | | description |
| "Merge SAFI-1 and SAFI-4 updates from neighbor"; | | "Merge SAFI-1 and SAFI-4 updates from neighbor"; |
| } | | } |
| leaf capability-negotiation-suppressed { | | leaf capability-negotiation-suppressed { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Disabling the capabilitynegotiation completely"; | n | "Capability negotiation is suppressed"; |
| } | | |
| leaf four-byte-as-capability-suppressed { | | |
| type uint32; | | |
| description | | |
| "Suppressing the 4-byte AS capability"; | | |
| } | | |
| leaf extended-nh-encoding-capability-suppressed { | | |
| type uint32; | | |
| description | | |
| "Disabling the extendednexthop encoding | | |
| capability"; | | |
| } | | } |
| leaf session-open-mode { | | leaf session-open-mode { |
| type Bgp-tcp-mode; | | type Bgp-tcp-mode; |
| description | | description |
| "TCP open mode to be used "; | | "TCP open mode to be used "; |
| } | | } |
| leaf bfd { | | leaf bfd { |
| type uint32; | | type uint32; |
| description | | description |
| "Fast failure detection using BFD"; | | "Fast failure detection using BFD"; |
| } | | } |
| leaf bfd-mininterval { | | leaf bfd-mininterval { |
| type uint32; | | type uint32; |
| description | | description |
| "BFD Minimum Interval"; | | "BFD Minimum Interval"; |
| } | | } |
| leaf bfd-multiplier { | | leaf bfd-multiplier { |
| type uint32; | | type uint32; |
| description | | description |
| "BFD Multiplier"; | | "BFD Multiplier"; |
| } | | } |
| leaf tos-type-info { | | leaf tos-type-info { |
| type uint8; | | type uint8; |
| description | | description |
| "Precedence or DSCP type"; | | "Precedence or DSCP type"; |
| } | | } |
| leaf tos-value-info { | | leaf tos-value-info { |
| type uint8; | | type uint8; |
| description | | description |
| "Precedence or DSCP value"; | | "Precedence or DSCP value"; |
| } | | } |
| leaf nsr-disabled { | | leaf nsr-disabled { |
| type uint32; | | type uint32; |
| description | | description |
| "Support for NSR"; | | "Support for NSR"; |
| } | | } |
| leaf graceful-restart-disabled { | | leaf graceful-restart-disabled { |
| type uint32; | | type uint32; |
| description | | description |
| "Support for graceful-restart"; | | "Support for graceful-restart"; |
| } | | } |
| n | leaf graceful-restart-helper-mode { | n | |
| type uint32; | | |
| description | | |
| "Enable graceful-restart in helper-mode only"; | | |
| } | | |
| leaf nbr-restart-time { | | leaf nbr-restart-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Restart time (in seconds)"; | | "Restart time (in seconds)"; |
| } | | } |
| leaf nbr-stale-path-time { | | leaf nbr-stale-path-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Stale-path time(in seconds)"; | | "Stale-path time(in seconds)"; |
| } | | } |
| leaf nbr-enforce-first-as-status { | | leaf nbr-enforce-first-as-status { |
| type boolean; | | type boolean; |
| description | | description |
| n | "Flag to indicate whether BGPneighbor enforced as | n | "Neighbor enforce first AS status"; |
| firstautonomous path"; | | |
| } | | } |
| leaf nbr-cluster-id-type-info { | | leaf nbr-cluster-id-type-info { |
| type uint8; | | type uint8; |
| description | | description |
| "Cluster ID Type"; | | "Cluster ID Type"; |
| } | | } |
| leaf nbr-cluster-id-info { | | leaf nbr-cluster-id-info { |
| type uint32; | | type uint32; |
| description | | description |
| "Cluster ID value"; | | "Cluster ID value"; |
| } | | } |
| leaf ignore-connected-check { | | leaf ignore-connected-check { |
| type boolean; | | type boolean; |
| description | | description |
| "If true, don't do NHconnected check for nbr"; | | "If true, don't do NHconnected check for nbr"; |
| } | | } |
| leaf internal-vpn-client { | | leaf internal-vpn-client { |
| type boolean; | | type boolean; |
| description | | description |
| "If true, the VPN client isan iBGP CE peer"; | | "If true, the VPN client isan iBGP CE peer"; |
| } | | } |
| leaf addpath-send-capability { | | leaf addpath-send-capability { |
| type uint32; | | type uint32; |
| description | | description |
| "Indicates if addpath send capability is enabled | | "Indicates if addpath send capability is enabled |
| or disabled"; | | or disabled"; |
| } | | } |
| leaf update-error-handling-no-reset { | | leaf update-error-handling-no-reset { |
| type uint32; | | type uint32; |
| description | | description |
| "Indicates if avoid-reset behavior is enabled | | "Indicates if avoid-reset behavior is enabled |
| during update error-handling"; | | during update error-handling"; |
| } | | } |
| leaf addpath-receive-capability { | | leaf addpath-receive-capability { |
| type uint32; | | type uint32; |
| description | | description |
| "Indicates if addpath receive capability is | | "Indicates if addpath receive capability is |
| enabled or disabled"; | | enabled or disabled"; |
| } | | } |
| leaf egress-peer-engineering { | | leaf egress-peer-engineering { |
| type uint32; | | type uint32; |
| description | | description |
| "Indicates egress peer engineering is enabled"; | | "Indicates egress peer engineering is enabled"; |
| } | | } |
| n | leaf epe-peer-sets { | n | |
| type string; | | |
| description | | |
| "Bitfields representing which EPE peer sets the | | |
| neighbor belongs to"; | | |
| } | | |
| leaf epe-peer-segment-id { | | |
| type uint32; | | |
| description | | |
| "Manual segment Index assigned for this neighbor"; | | |
| } | | |
| leaf prefix-validation-disable { | | leaf prefix-validation-disable { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Disabeling the BGP bestpathprefix validation"; | n | "Prefix validation disable"; |
| } | | } |
| leaf bestpath-use-origin-as-validity { | | leaf bestpath-use-origin-as-validity { |
| type uint32; | | type uint32; |
| description | | description |
| "Bestpath Use Origin-AS Va"; | | "Bestpath Use Origin-AS Va"; |
| } | | } |
| leaf prefix-validation-allow-invalid { | | leaf prefix-validation-allow-invalid { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Allowing an invalid prefixas the BGP best path"; | n | "Prefix validation allow invalid"; |
| } | | } |
| leaf prefix-validation-signal-ibgp { | | leaf prefix-validation-signal-ibgp { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Performs a prefix origin validationfor internal | n | "Prefix validation signal ibgp"; |
| BGP"; | | |
| } | | } |
| leaf neighbor-update-filter-exists { | | leaf neighbor-update-filter-exists { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates if neighbor filter configuration | | "Indicates if neighbor filter configuration |
| exists"; | | exists"; |
| } | | } |
| leaf neighbor-update-filter-message-buffer-count { | | leaf neighbor-update-filter-message-buffer-count { |
| type uint32; | | type uint32; |
| description | | description |
| "Count of neighbor filter message buffers"; | | "Count of neighbor filter message buffers"; |
| } | | } |
| leaf neighbor-update-filter-message-buffer-is-non-circular { | | leaf neighbor-update-filter-message-buffer-is-non-circular { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates if neighbor update filter message | | "Indicates if neighbor update filter message |
| buffer is circular or not"; | | buffer is circular or not"; |
| } | | } |
| leaf neighbor-update-filter-logging-disable { | | leaf neighbor-update-filter-logging-disable { |
| type boolean; | | type boolean; |
| description | | description |
| "Indicates if neighbor filter logging is disabled"; | | "Indicates if neighbor filter logging is disabled"; |
| } | | } |
| leaf neighbor-update-filter-attribute-filter-group-name { | | leaf neighbor-update-filter-attribute-filter-group-name { |
| type string; | | type string; |
| description | | description |
| n | "Name of the update filter attributefilter of the | n | "Neighbor filter attribute-filter group name"; |
| neighbor"; | | |
| } | | } |
| leaf graceful-shutdown-exists { | | leaf graceful-shutdown-exists { |
| type uint32; | | type uint32; |
| description | | description |
| "re-advertise all routes to and from this | | "re-advertise all routes to and from this |
| neighbor with the GSHUT community during | | neighbor with the GSHUT community during |
| Shutdown or bring-up"; | | Shutdown or bring-up"; |
| } | | } |
| leaf graceful-shutdown-loc-pref { | | leaf graceful-shutdown-loc-pref { |
| type uint32; | | type uint32; |
| description | | description |
| "Local Preference to advertise routes with during | | "Local Preference to advertise routes with during |
| Graceful Shutdown to IBGP. Default=No Touch"; | | Graceful Shutdown to IBGP. Default=No Touch"; |
| } | | } |
| leaf graceful-shutdown-as-prepends { | | leaf graceful-shutdown-as-prepends { |
| type uint32; | | type uint32; |
| description | | description |
| "Prepend the local AS this many times to the AS | | "Prepend the local AS this many times to the AS |
| path of routes advertised during Graceful | | path of routes advertised during Graceful |
| Shutdown"; | | Shutdown"; |
| } | | } |
| leaf graceful-shutdown-activate { | | leaf graceful-shutdown-activate { |
| type uint32; | | type uint32; |
| description | | description |
| "Graceful Shutdown state is activated"; | | "Graceful Shutdown state is activated"; |
| } | | } |
| n | leaf graceful-shutdown-bandwidth-aware-mode { | n | |
| type Bgp-gshut-bw-mode; | | |
| description | | |
| "Bandwidth-Aware Graceful-Maintenance mode"; | | |
| } | | |
| leaf graceful-shutdown-bandwidth-aware-low-threshold { | | |
| type uint32; | | |
| description | | |
| "Bandwidth-Aware Graceful-Maintenance Low | | |
| threshold"; | | |
| } | | |
| leaf graceful-shutdown-bandwidth-aware-high-threshold { | | |
| type uint32; | | |
| description | | |
| "Bandwidth-Aware Graceful-Maintenance High | | |
| threshold"; | | |
| } | | |
| leaf neighbor-remote-as-list-group-name { | | leaf neighbor-remote-as-list-group-name { |
| type string; | | type string; |
| description | | description |
| n | "Name of the remote atonomous system list group | n | "Neighbor Range remote-as-list group name"; |
| of neighbor"; | | |
| } | | } |
| leaf max-peers { | | leaf max-peers { |
| type uint32; | | type uint32; |
| description | | description |
| "Maximum dynamic nbrs in range"; | | "Maximum dynamic nbrs in range"; |
| } | | } |
| leaf idle-watch-time { | | leaf idle-watch-time { |
| type uint32; | | type uint32; |
| units "second"; | | units "second"; |
| description | | description |
| "Idle Watch time(in seconds)"; | | "Idle Watch time(in seconds)"; |
| } | | } |
| leaf ao-keychain { | | leaf ao-keychain { |
| type string; | | type string; |
| description | | description |
| "Neighbor AO keychain name"; | | "Neighbor AO keychain name"; |
| } | | } |
| leaf ao-include-tcp-options { | | leaf ao-include-tcp-options { |
| type uint32; | | type uint32; |
| description | | description |
| "Include TCP options AO"; | | "Include TCP options AO"; |
| } | | } |
| leaf ao-accept-mismatch-connection { | | leaf ao-accept-mismatch-connection { |
| type uint32; | | type uint32; |
| description | | description |
| n | "Accepting mismatch connectionfor AO"; | n | "Accept AO mismatched connection"; |
| } | | |
| leaf default-policy-action-inbound { | | |
| type uint32; | | |
| description | | |
| "Default Action for a route when inbound policy | | |
| definition is not satidfied"; | | |
| } | | |
| leaf default-policy-action-outbound { | | |
| type uint32; | | |
| description | | |
| "Default Action for a route when outbound policy | | |
| definition is not satidfied"; | | |
| } | | |
| leaf maximum-prefix-restart-time { | | |
| type uint32; | | |
| units "second"; | | |
| description | | |
| "Max Prefix Restart timer (in seconds)"; | | |
| } | | |
| leaf default-allowas { | | |
| type uint32; | | |
| description | | |
| "Default allowas_in count"; | | |
| } | | } |
| leaf local-as-replace-as { | | leaf local-as-replace-as { |
| type boolean; | | type boolean; |
| description | | description |
| "Local AS Replace-AS option"; | | "Local AS Replace-AS option"; |
| } | | } |
| leaf local-as-dual-as { | | leaf local-as-dual-as { |
| type boolean; | | type boolean; |
| description | | description |
| "Local AS Dual-AS option"; | | "Local AS Dual-AS option"; |
| n | } | n | |
| leaf evpn-link-bandwidth { | | |
| type boolean; | | |
| description | | |
| "EVPN Link Bandwidth Enabled"; | | |
| } | | |
| leaf evpn-link-bandwidth-type { | | |
| type Bgp-evpn-link-bw-edm; | | |
| description | | |
| "EVPN Link Bandwidth Value-Unit type"; | | |
| } | | |
| leaf evpn-link-bandwidth-weight { | | |
| type uint32; | | |
| description | | |
| "EVPN Link Bandwidth Value-Weight"; | | |
| } | | |
| leaf sent-community-to-neighbor { | | |
| type boolean; | | |
| description | | |
| "Flag Send Community"; | | |
| } | | |
| leaf sent-extended-community-to-neighbor { | | |
| type boolean; | | |
| description | | |
| "Flag Send ExtendedCommunity"; | | |
| } | | |
| leaf dampening { | | |
| type Bgp-nbr-dampening; | | |
| description | | |
| "neighbor route-dampening is enabled"; | | |
| } | | |
| leaf is-as-override-disabled { | | |
| type Bgp-nbr-aspath-as-override; | | |
| description | | |
| "Disable as override"; | | |
| } | | |
| leaf neighbor-disable-peer-as { | | |
| type Bgp-nbr-disable-peer-as; | | |
| description | | |
| "Neighbor Disable Peer AS"; | | |
| } | | |
| leaf nbr-fast-fallover { | | |
| type uint32; | | |
| description | | |
| "Fast Fallover"; | | |
| } | | |
| leaf ipfwd-preferred { | | |
| type boolean; | | |
| description | | |
| "IP Forwarding Enabled"; | | |
| } | | } |
| } | | } |
| | | |
| grouping BGP-IPV6-SRPOLICY-ADDR { | | grouping BGP-IPV6-SRPOLICY-ADDR { |
| description | | description |
| "BGP IPV6 SRPOLICY ADDR"; | | "BGP IPV6 SRPOLICY ADDR"; |
| leaf ipv6-srpolicy-address { | | leaf ipv6-srpolicy-address { |
| type yang:hex-string; | | type yang:hex-string; |
| description | | description |
| n | "IPv6 address of thesrpolicy"; | n | "ipv6 srpolicy address"; |
| } | | } |
| } | | } |
| | | |
| grouping IPV6-SR-POLICY-ADDRESS-TYPE { | | grouping IPV6-SR-POLICY-ADDRESS-TYPE { |
| description | | description |
| "IPv6 SR Policy Address type"; | | "IPv6 SR Policy Address type"; |
| uses BGP-IPV6-SRPOLICY-ADDR; | | uses BGP-IPV6-SRPOLICY-ADDR; |
| } | | } |
| | | |
| grouping BGP-IPV4-SRPOLICY-ADDR { | | grouping BGP-IPV4-SRPOLICY-ADDR { |
| description | | description |
| "BGP IPV4 SRPOLICY ADDR"; | | "BGP IPV4 SRPOLICY ADDR"; |
| leaf ipv4-srpolicy-address { | | leaf ipv4-srpolicy-address { |
| type yang:hex-string; | | type yang:hex-string; |
| description | | description |
| n | "IPv4 address of thesrpolicy"; | n | "ipv4 srpolicy address"; |
| } | | } |
| } | | } |
| | | |
| grouping IPV4-SR-POLICY-ADDRESS-TYPE { | | grouping IPV4-SR-POLICY-ADDRESS-TYPE { |
| description | | description |
| "IPv4 SR Policy Address type"; | | "IPv4 SR Policy Address type"; |
| uses BGP-IPV4-SRPOLICY-ADDR; | | uses BGP-IPV4-SRPOLICY-ADDR; |
| } | | } |
| | | |
| grouping BGP-L2VPN-MSPW-ADDR { | | grouping BGP-L2VPN-MSPW-ADDR { |
| description | | description |
| "BGP L2VPN MSPW ADDR"; | | "BGP L2VPN MSPW ADDR"; |
| leaf l2vpn-address { | | leaf l2vpn-address { |
| type yang:hex-string; | | type yang:hex-string; |
| description | | description |
| n | "L2vpn address of the BGP mspw"; | n | "l2vpn address"; |
| } | | } |
| } | | } |
| | | |
| grouping L2VPN-MSPW-ADDRESS-TYPE { | | grouping L2VPN-MSPW-ADDRESS-TYPE { |
| description | | description |
| "L2VPN MSPW Address type"; | | "L2VPN MSPW Address type"; |
| uses BGP-L2VPN-MSPW-ADDR; | | uses BGP-L2VPN-MSPW-ADDR; |
| n | } | n | |
| | | |
| grouping BGP-L2VPN-EVPN-ADDR { | | |
| description | | |
| "BGP L2VPN EVPN ADDR"; | | |
| leaf l2vpn-evpn-address { | | |
| type yang:hex-string; | | |
| description | | |
| "l2vpn evpn address"; | | |
| } | | |
| } | | |
| | | |
| grouping L2VPN-EVPN-ADDRESS-TYPE { | | |
| description | | |
| "L2VPN EVPN Address type"; | | |
| uses BGP-L2VPN-EVPN-ADDR; | | |
| } | | } |
| | | |
| grouping BGP-L2VPN-ADDR { | | grouping BGP-L2VPN-ADDR { |
| description | | description |
| "BGP L2VPN ADDR"; | | "BGP L2VPN ADDR"; |
| leaf l2vpn-address { | | leaf l2vpn-address { |
| type yang:hex-string; | | type yang:hex-string; |
| description | | description |
| n | "L2vpn address of the protocol BGP"; | n | "l2vpn address"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-ADDRTYPE { | | grouping BGP-ADDRTYPE { |
| description | | description |
| "BGP ADDRTYPE"; | | "BGP ADDRTYPE"; |
| container l2vpn-vpls-address { | | container l2vpn-vpls-address { |
| when "../afi = 'l2vpn-vpls'" { | | when "../afi = 'l2vpn-vpls'" { |
| description | | description |
| "../AFI = 'L2VPN_VPLS'"; | | "../AFI = 'L2VPN_VPLS'"; |
| } | | } |
| description | | description |
| "L2VPN VPLS Addr"; | | "L2VPN VPLS Addr"; |
| uses BGP-L2VPN-ADDR; | | uses BGP-L2VPN-ADDR; |
| } | | } |
| n | container l2vpn-evpn-address { | n | |
| when "../afi = 'l2vpn-evpn'" { | | |
| description | | |
| "../AFI = 'L2VPN_EVPN'"; | | |
| } | | |
| description | | |
| "L2VPN EVPN Addr"; | | |
| uses L2VPN-EVPN-ADDRESS-TYPE; | | |
| } | | |
| container l2vpn-mspw-address { | | container l2vpn-mspw-address { |
| when "../afi = 'l2vpn-mspw'" { | | when "../afi = 'l2vpn-mspw'" { |
| description | | description |
| "../AFI = 'L2VPN_MSPW'"; | | "../AFI = 'L2VPN_MSPW'"; |
| } | | } |
| description | | description |
| "L2VPN MSPW Addr"; | | "L2VPN MSPW Addr"; |
| uses L2VPN-MSPW-ADDRESS-TYPE; | | uses L2VPN-MSPW-ADDRESS-TYPE; |
| } | | } |
| container ipv4-sr-policy-address { | | container ipv4-sr-policy-address { |
| when "../afi = 'ipv4-sr-policy'" { | | when "../afi = 'ipv4-sr-policy'" { |
| description | | description |
| "../AFI = 'IPv4SRPolicy'"; | | "../AFI = 'IPv4SRPolicy'"; |
| } | | } |
| description | | description |
| "IPV4 Policy Addr"; | | "IPV4 Policy Addr"; |
| uses IPV4-SR-POLICY-ADDRESS-TYPE; | | uses IPV4-SR-POLICY-ADDRESS-TYPE; |
| } | | } |
| container ipv6-sr-policy-address { | | container ipv6-sr-policy-address { |
| when "../afi = 'ipv6-sr-policy'" { | | when "../afi = 'ipv6-sr-policy'" { |
| description | | description |
| "../AFI = 'IPv6SRPolicy'"; | | "../AFI = 'IPv6SRPolicy'"; |
| } | | } |
| description | | description |
| "IPV6 Policy Addr"; | | "IPV6 Policy Addr"; |
| uses IPV6-SR-POLICY-ADDRESS-TYPE; | | uses IPV6-SR-POLICY-ADDRESS-TYPE; |
| } | | } |
| leaf afi { | | leaf afi { |
| type Bgp-afi; | | type Bgp-afi; |
| description | | description |
| "AFI"; | | "AFI"; |
| } | | } |
| leaf ipv4-address { | | leaf ipv4-address { |
| when "../afi = 'ipv4'" { | | when "../afi = 'ipv4'" { |
| description | | description |
| "../AFI = 'IPv4'"; | | "../AFI = 'IPv4'"; |
| } | | } |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "IPv4 Addr"; | | "IPv4 Addr"; |
| } | | } |
| leaf ipv4-mcast-address { | | leaf ipv4-mcast-address { |
| when "../afi = 'ipv4-multicast'" { | | when "../afi = 'ipv4-multicast'" { |
| description | | description |
| "../AFI = 'IPv4Multicast'"; | | "../AFI = 'IPv4Multicast'"; |
| } | | } |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "IPv4 Mcast Addr"; | | "IPv4 Mcast Addr"; |
| } | | } |
| leaf ipv4-label-address { | | leaf ipv4-label-address { |
| when "../afi = 'ipv4-labeled'" { | | when "../afi = 'ipv4-labeled'" { |
| description | | description |
| "../AFI = 'IPv4Labeled'"; | | "../AFI = 'IPv4Labeled'"; |
| } | | } |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "IPv4 Label Addr"; | | "IPv4 Label Addr"; |
| } | | } |
| leaf ipv4-tunnel-address { | | leaf ipv4-tunnel-address { |
| when "../afi = 'ipv4-tunnel'" { | | when "../afi = 'ipv4-tunnel'" { |
| description | | description |
| "../AFI = 'IPv4Tunnel'"; | | "../AFI = 'IPv4Tunnel'"; |
| } | | } |
| type Ipv4-tunnel-address; | | type Ipv4-tunnel-address; |
| description | | description |
| "IPv4 Tunnel"; | | "IPv4 Tunnel"; |
| } | | } |
| leaf ipv4-mdt-address { | | leaf ipv4-mdt-address { |
| when "../afi = 'ipv4-mdt'" { | | when "../afi = 'ipv4-mdt'" { |
| description | | description |
| "../AFI = 'IPv4MDT'"; | | "../AFI = 'IPv4MDT'"; |
| } | | } |
| type Ipv4-mdt-address; | | type Ipv4-mdt-address; |
| description | | description |
| "IPv4 MDT Addr"; | | "IPv4 MDT Addr"; |
| } | | } |
| leaf ipv4vpn-address { | | leaf ipv4vpn-address { |
| when "../afi = 'vpnv4'" { | | when "../afi = 'vpnv4'" { |
| description | | description |
| "../AFI = 'VPNv4'"; | | "../AFI = 'VPNv4'"; |
| } | | } |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "IPv4 VPN Addr"; | | "IPv4 VPN Addr"; |
| } | | } |
| leaf ipv4vpna-mcastddress { | | leaf ipv4vpna-mcastddress { |
| when "../afi = 'vpnv4-multicast'" { | | when "../afi = 'vpnv4-multicast'" { |
| description | | description |
| "../AFI = 'VPNv4Multicast'"; | | "../AFI = 'VPNv4Multicast'"; |
| } | | } |
| type inet:ipv4-address; | | type inet:ipv4-address; |
| description | | description |
| "IPv4 VPN Mcast Addr"; | | "IPv4 VPN Mcast Addr"; |
| } | | } |
| leaf ipv6-address { | | leaf ipv6-address { |
| when "../afi = 'ipv6'" { | | when "../afi = 'ipv6'" { |
| description | | description |
| "../AFI = 'IPv6'"; | | "../AFI = 'IPv6'"; |
| } | | } |
| type Ipv6-address; | | type Ipv6-address; |
| description | | description |
| "IPV6 Addr"; | | "IPV6 Addr"; |
| } | | } |
| leaf ipv6-mcast-address { | | leaf ipv6-mcast-address { |
| when "../afi = 'ipv6-multicast'" { | | when "../afi = 'ipv6-multicast'" { |
| description | | description |
| "../AFI = 'IPv6Multicast'"; | | "../AFI = 'IPv6Multicast'"; |
| } | | } |
| type Ipv6-address; | | type Ipv6-address; |
| description | | description |
| "IPV6 Mcast Addr"; | | "IPV6 Mcast Addr"; |
| } | | } |
| leaf ipv6-label-address { | | leaf ipv6-label-address { |
| when "../afi = 'ipv6-labeled'" { | | when "../afi = 'ipv6-labeled'" { |
| description | | description |
| "../AFI = 'IPv6Labeled'"; | | "../AFI = 'IPv6Labeled'"; |
| } | | } |
| type Ipv6-address; | | type Ipv6-address; |
| description | | description |
| "IPv6 Label Addr"; | | "IPv6 Label Addr"; |
| } | | } |
| leaf ipv6vpn-address { | | leaf ipv6vpn-address { |
| when "../afi = 'vpnv6'" { | | when "../afi = 'vpnv6'" { |
| description | | description |
| "../AFI = 'VPNv6'"; | | "../AFI = 'VPNv6'"; |
| } | | } |
| type Ipv6-address; | | type Ipv6-address; |
| description | | description |
| "IPv6 VPN Addr"; | | "IPv6 VPN Addr"; |
| } | | } |
| leaf ipv6vpn-mcast-address { | | leaf ipv6vpn-mcast-address { |
| when "../afi = 'vpnv6-multicast'" { | | when "../afi = 'vpnv6-multicast'" { |
| description | | description |
| "../AFI = 'VPNv6Multicast'"; | | "../AFI = 'VPNv6Multicast'"; |
| } | | } |
| type Ipv6-address; | | type Ipv6-address; |
| description | | description |
| "IPv6 VPN Mcast Addr"; | | "IPv6 VPN Mcast Addr"; |
| } | | } |
| leaf rt-constraint-address { | | leaf rt-constraint-address { |
| when "../afi = 'rt-constraint'" { | | when "../afi = 'rt-constraint'" { |
| description | | description |
| "../AFI = 'RTConstraint'"; | | "../AFI = 'RTConstraint'"; |
| } | | } |
| type Rt-constraint-address; | | type Rt-constraint-address; |
| description | | description |
| "RT Constrt Addr"; | | "RT Constrt Addr"; |
| } | | } |
| leaf ipv6mvpn-address { | | leaf ipv6mvpn-address { |
| when "../afi = 'ipv6-mvpn'" { | | when "../afi = 'ipv6-mvpn'" { |
| description | | description |
| "../AFI = 'IPv6MVPN'"; | | "../AFI = 'IPv6MVPN'"; |
| } | | } |
| type Ipv6mvpn-address; | | type Ipv6mvpn-address; |
| description | | description |
| "MVPN addr"; | | "MVPN addr"; |
| } | | } |
| leaf ipv4mvpn-address { | | leaf ipv4mvpn-address { |
| when "../afi = 'ipv4-mvpn'" { | | when "../afi = 'ipv4-mvpn'" { |
| description | | description |
| "../AFI = 'IPv4MVPN'"; | | "../AFI = 'IPv4MVPN'"; |
| } | | } |
| type Ipv4mvpn-address; | | type Ipv4mvpn-address; |
| description | | description |
| "MVPN4 addr"; | | "MVPN4 addr"; |
| } | | } |
| n | | n | leaf l2vpn-evpn-address { |
| | | when "../afi = 'l2vpn-evpn'" { |
| | | description |
| | | "../AFI = 'L2VPN_EVPN'"; |
| | | } |
| | | type L2vpn-evpn-address; |
| | | description |
| | | "L2VPN EVPN Addr"; |
| | | } |
| leaf ls-ls-address { | | leaf ls-ls-address { |
| when "../afi = 'ls-ls'" { | | when "../afi = 'ls-ls'" { |
| description | | description |
| "../AFI = 'LS_LS'"; | | "../AFI = 'LS_LS'"; |
| } | | } |
| type Ls-ls-address; | | type Ls-ls-address; |
| description | | description |
| "LINKSTATE LINKSTATE Addr"; | | "LINKSTATE LINKSTATE Addr"; |
| } | | } |
| leaf ipv4-flowspec-address { | | leaf ipv4-flowspec-address { |
| when "../afi = 'ipv4-flowspec'" { | | when "../afi = 'ipv4-flowspec'" { |
| description | | description |
| "../AFI = 'IPv4Flowspec'"; | | "../AFI = 'IPv4Flowspec'"; |
| } | | } |
| type Ipv4-flowspec-address; | | type Ipv4-flowspec-address; |
| description | | description |
| "IPV4 Flowspec Addr"; | | "IPV4 Flowspec Addr"; |
| } | | } |
| leaf ipv6-flowspec-address { | | leaf ipv6-flowspec-address { |
| when "../afi = 'ipv6-flowspec'" { | | when "../afi = 'ipv6-flowspec'" { |
| description | | description |
| "../AFI = 'IPv6Flowspec'"; | | "../AFI = 'IPv6Flowspec'"; |
| } | | } |
| type Ipv6-flowspec-address; | | type Ipv6-flowspec-address; |
| description | | description |
| "IPV6 Flowspec Addr"; | | "IPV6 Flowspec Addr"; |
| } | | } |
| leaf ipv4vpn-flowspec-address { | | leaf ipv4vpn-flowspec-address { |
| when "../afi = 'vpnv4-flowspec'" { | | when "../afi = 'vpnv4-flowspec'" { |
| description | | description |
| "../AFI = 'VPNv4Flowspec'"; | | "../AFI = 'VPNv4Flowspec'"; |
| } | | } |
| type Ipv4-flowspec-address; | | type Ipv4-flowspec-address; |
| description | | description |
| "IPV4 VPN Flowspec Addr"; | | "IPV4 VPN Flowspec Addr"; |
| } | | } |
| leaf ipv6vpn-flowspec-address { | | leaf ipv6vpn-flowspec-address { |
| when "../afi = 'vpnv6-flowspec'" { | | when "../afi = 'vpnv6-flowspec'" { |
| description | | description |
| "../AFI = 'VPNv6Flowspec'"; | | "../AFI = 'VPNv6Flowspec'"; |
| } | | } |
| type Ipv6-flowspec-address; | | type Ipv6-flowspec-address; |
| description | | description |
| "IPV6 VPN Flowspec Addr"; | | "IPV6 VPN Flowspec Addr"; |
| } | | } |
| } | | } |
| | | |
| grouping BGP-CONFIG-ENTITY-BAG { | | grouping BGP-CONFIG-ENTITY-BAG { |
| description | | description |
| "BGP entity config information"; | | "BGP entity config information"; |
| container neighbor-address-xr { | | container neighbor-address-xr { |
| description | | description |
| "Neighbor Address"; | | "Neighbor Address"; |
| uses BGP-ADDRTYPE; | | uses BGP-ADDRTYPE; |
| } | | } |
| container af-independent-config { | | container af-independent-config { |
| description | | description |
| n | "BGP address-family independentconfiguration"; | n | "AF-independent config"; |
| uses BGP-AF-INDEP; | | uses BGP-AF-INDEP; |
| } | | } |
| leaf group-name { | | leaf group-name { |
| type string; | | type string; |
| description | | description |
| "Entity/group name"; | | "Entity/group name"; |
| } | | } |
| leaf configuration-type { | | leaf configuration-type { |
| type Bgp-entities; | | type Bgp-entities; |
| description | | description |
| "Entity type"; | | "Entity type"; |
| } | | } |
| leaf address-family-identifier { | | leaf address-family-identifier { |
| n | type string; | n | type uint8; |
| description | | description |
| "AF identifier"; | | "AF identifier"; |
| } | | } |
| list af-dependent-config { | | list af-dependent-config { |
| max-elements "25"; | | max-elements "25"; |
| description | | description |
| t | "Dependent configuration peraddress-family"; | t | "Af-dependent config"; |
| uses BGP-AF-DEP; | | uses BGP-AF-DEP; |
| } | | } |
| } | | } |
| } | | } |